From ea93834515d3fea3de84461f3abdb6cf5ea5cb10 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Thu, 20 Aug 2026 12:04:08 +0000 Subject: [PATCH 1/5] perf(ixvm): share argument-independent substitution work Large beta-reduction traces can instantiate the same expression with many different arguments even when a subtree does not reference the substituted binder. Since the argument is part of the memo key, the kernel previously rebuilt those argument-independent subtrees for every application. Detect exact loose-BVar occurrence for single substitution and lower argument-independent subtrees through the existing memoized path. Apply the analogous substitution-window check to simultaneous substitution, including an explicit empty-list fast path. Leave the ordinary substitution walks and expr_lower_walk circuit layout unchanged. A focused bytecode check of Algebra.TensorProduct.toLinearEquiv_tensorTensorTensorComm passes at 403.031B FFT. The patch intentionally excludes the mechanical expr_lower_walk helper split from the earlier experiment. --- Ix/IxVM/Kernel/Subst.lean | 60 ++++++++++++++++++++++++++++++++++++--- 1 file changed, 56 insertions(+), 4 deletions(-) diff --git a/Ix/IxVM/Kernel/Subst.lean b/Ix/IxVM/Kernel/Subst.lean index b55ca08f..5250e581 100644 --- a/Ix/IxVM/Kernel/Subst.lean +++ b/Ix/IxVM/Kernel/Subst.lean @@ -420,13 +420,56 @@ def subst := ⟦ -- with a list of one element. For the lambda-eta case in def_eq we want -- `body[BVar(0) := arg]` which is `expr_inst1(body, arg, 0)`. -- ============================================================================ + -- Exact occurrence of the substitution target. Unlike `expr_lbr`, this + -- distinguishes a subtree that mentions only variables ABOVE `depth`: such + -- a subtree still has to be lowered after removing the binder, but its + -- result is independent of `arg`. Memoizing this predicate by `(e, depth)` + -- lets all arguments share that lowering path. + fn expr_has_bvar_at(e: KExpr, depth: G) -> G { + match load(e) { + KExprNode.BVar(i) => match i - depth { 0 => 1, _ => 0, }, + KExprNode.App(f, a) => + match expr_has_bvar_at(f, depth) { + 1 => 1, + _ => expr_has_bvar_at(a, depth), + }, + KExprNode.Lam(ty, body) => expr_has_bvar_at_binder(ty, body, depth), + KExprNode.Forall(ty, body) => expr_has_bvar_at_binder(ty, body, depth), + KExprNode.Let(ty, val, body) => expr_has_bvar_at_let(ty, val, body, depth), + KExprNode.Proj(_, _, inner) => expr_has_bvar_at(inner, depth), + _ => 0, + } + } + + fn expr_has_bvar_at_binder(ty: KExpr, body: KExpr, depth: G) -> G { + match expr_has_bvar_at(ty, depth) { + 1 => 1, + _ => expr_has_bvar_at(body, depth + 1), + } + } + + fn expr_has_bvar_at_let(ty: KExpr, val: KExpr, body: KExpr, depth: G) -> G { + match expr_has_bvar_at(ty, depth) { + 1 => 1, + _ => + match expr_has_bvar_at(val, depth) { + 1 => 1, + _ => expr_has_bvar_at(body, depth + 1), + }, + } + } + fn expr_inst1(e: KExpr, arg: KExpr, depth: G) -> KExpr { -- Fast path: when `expr_lbr(e) <= depth`, no BVar at or above depth -- exists in `e`, so the substitution is a no-op. let l = expr_lbr(e); match memo_u32_less_than(depth, l) { 0 => e, - 1 => expr_inst1_walk(e, arg, depth), + 1 => + match expr_has_bvar_at(e, depth) { + 1 => expr_inst1_walk(e, arg, depth), + _ => expr_lower(e, 1, depth + 1), + }, } } @@ -489,10 +532,19 @@ def subst := ⟦ -- `BVar(i ≥ depth+n)` shifts down by `n`. Same fast-path as `expr_inst1`. -- ============================================================================ fn expr_inst_many(e: KExpr, substs: List‹KExpr›, depth: G) -> KExpr { - let l = expr_lbr(e); - match memo_u32_less_than(depth, l) { + let n = list_length(substs); + match n { 0 => e, - 1 => expr_inst_many_walk(e, substs, depth), + _ => + let l = expr_lbr(e); + match memo_u32_less_than(depth, l) { + 0 => e, + 1 => + match has_bvar_in_range(e, depth, depth + n) { + 1 => expr_inst_many_walk(e, substs, depth), + _ => expr_lower(e, n, depth + n), + }, + }, } } From bfa213dd0f33e5f11193cd562c0a295aa2fbfd6c Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Thu, 20 Aug 2026 12:22:23 +0000 Subject: [PATCH 2/5] fix(ixvm): decline struct eta for out-of-scope majors MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Struct-eta iota is a speculative reduction, but it unconditionally inferred the stuck major. During canonical recursor reconstruction, WHNF can encounter a loose major under a deliberately empty local-type context; attempting inference then indexed past the context and aborted with an unmatched list case. Check the major's loose-BVar range against the supplied type context before attempting struct eta. If the major is not scoped, leave the recursor stuck and let ordinary reduction continue, matching the reference behavior when speculative inference cannot establish a type. This fixes SSet.prodStdSimplex.pairingCore.Type₁.rec, which was the shared failure in FLT shard 145 and Mathlib shard 226. The focused constant and both shards pass under bytecode interpretation. --- Ix/IxVM/Kernel/Whnf.lean | 33 +++++++++++++++++++++++---------- 1 file changed, 23 insertions(+), 10 deletions(-) diff --git a/Ix/IxVM/Kernel/Whnf.lean b/Ix/IxVM/Kernel/Whnf.lean index aeebd513..e3b384ae 100644 --- a/Ix/IxVM/Kernel/Whnf.lean +++ b/Ix/IxVM/Kernel/Whnf.lean @@ -934,18 +934,31 @@ def whnf := ⟦ 1 => (0, store(KExprNode.BVar(0))), _ => let major = list_lookup(spine, skip); - let major_ty = k_infer(major, types); - match is_prop_type(major_ty, types) { + -- Struct-eta is speculative. During + -- canonical recursor reconstruction, WHNF + -- can encounter a loose major under a + -- deliberately empty local context. The + -- reference declines eta when inference + -- cannot establish the major's type; do + -- the same instead of indexing past + -- `types` in `k_infer`. + match memo_u32_less_than(list_length(types), + expr_lbr(major)) { 1 => (0, store(KExprNode.BVar(0))), _ => - let rhs_inst = expr_inst_levels(rhs, lvls); - let pmm = list_take(spine, - (nparams + nmotives) + nminors); - let after_pmm = apply_spine(rhs_inst, pmm); - let with_projs = apply_n_projs( - after_pmm, parent, major, nf, 0); - let post = list_drop(spine, skip + 1); - (1, apply_spine(with_projs, post)), + let major_ty = k_infer(major, types); + match is_prop_type(major_ty, types) { + 1 => (0, store(KExprNode.BVar(0))), + _ => + let rhs_inst = expr_inst_levels(rhs, lvls); + let pmm = list_take(spine, + (nparams + nmotives) + nminors); + let after_pmm = apply_spine(rhs_inst, pmm); + let with_projs = apply_n_projs( + after_pmm, parent, major, nf, 0); + let post = list_drop(spine, skip + 1); + (1, apply_spine(with_projs, post)), + }, }, }, _ => (0, store(KExprNode.BVar(0))), From f8d8fd7ae123af88d7d1da620ee14d76010dfb0a Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Thu, 20 Aug 2026 14:23:52 +0000 Subject: [PATCH 3/5] perf(ixvm): reduce closed Int primitives natively Recognize canonical Int literals and evaluate closed arithmetic, Euclidean and balanced division/modulus, natAbs, and powers through KLimbs. This avoids expanding the logical Int definitions into large Nat reduction chains during WHNF.\n\nPrimitive addresses are covered by the elaborated IxVM address-parity suite. The focused Batteries Char casing proof still needs further defeq work, but this removes the catastrophic Int expansion encountered along that path. --- Ix/IxVM/Kernel/NatPrim.lean | 199 ++++++++++++++++++++++++++++++++++++ Ix/IxVM/Kernel/Whnf.lean | 5 +- 2 files changed, 202 insertions(+), 2 deletions(-) diff --git a/Ix/IxVM/Kernel/NatPrim.lean b/Ix/IxVM/Kernel/NatPrim.lean index cabd6918..39da6c18 100644 --- a/Ix/IxVM/Kernel/NatPrim.lean +++ b/Ix/IxVM/Kernel/NatPrim.lean @@ -59,6 +59,20 @@ def natPrim := ⟦ 0xfcu8, 0x44u8, 0x77u8, 0xe0u8, 0xe9u8, 0x59u8, 0x4cu8, 0x88u8]) } + fn int_of_nat_addr() -> Addr { store([0x09u8, 0xbcu8, 0x25u8, 0x31u8, 0x47u8, 0xc3u8, 0x6cu8, 0xe2u8, 0x2cu8, 0x8eu8, 0x0cu8, 0xcdu8, 0x43u8, 0xc7u8, 0x9bu8, 0x2cu8, 0xdau8, 0xe2u8, 0x20u8, 0x6eu8, 0x0du8, 0xddu8, 0x16u8, 0x8fu8, 0xcau8, 0x36u8, 0x09u8, 0xb2u8, 0xa5u8, 0x84u8, 0xd3u8, 0xdcu8]) } + fn int_neg_succ_addr() -> Addr { store([0x26u8, 0x7cu8, 0x0au8, 0x9cu8, 0x92u8, 0xe7u8, 0x56u8, 0x38u8, 0xfcu8, 0x73u8, 0xedu8, 0x52u8, 0xa9u8, 0xf9u8, 0xc8u8, 0x16u8, 0x47u8, 0xeeu8, 0xecu8, 0xeeu8, 0xffu8, 0x21u8, 0x44u8, 0xc1u8, 0xf9u8, 0x7eu8, 0x65u8, 0xe2u8, 0xafu8, 0xf1u8, 0x49u8, 0xf1u8]) } + fn int_add_addr() -> Addr { store([0xb6u8, 0xbbu8, 0xacu8, 0x00u8, 0xc8u8, 0xe4u8, 0x6fu8, 0x8bu8, 0x86u8, 0x40u8, 0x29u8, 0x8fu8, 0x4cu8, 0x9au8, 0xc8u8, 0x94u8, 0xcbu8, 0xcdu8, 0x01u8, 0x01u8, 0x03u8, 0x5eu8, 0xddu8, 0x54u8, 0x3fu8, 0x7cu8, 0x43u8, 0x4eu8, 0x2cu8, 0x9fu8, 0xe9u8, 0x26u8]) } + fn int_sub_addr() -> Addr { store([0xbcu8, 0xb0u8, 0x9bu8, 0xa4u8, 0x3fu8, 0x8bu8, 0xdau8, 0xe6u8, 0x5cu8, 0x56u8, 0xa4u8, 0x7fu8, 0xf7u8, 0x7bu8, 0x50u8, 0xb4u8, 0x2eu8, 0xdeu8, 0x12u8, 0x0fu8, 0xbcu8, 0xdbu8, 0xa8u8, 0x46u8, 0x9eu8, 0x79u8, 0x9au8, 0x21u8, 0xf1u8, 0x2fu8, 0xd3u8, 0x89u8]) } + fn int_mul_addr() -> Addr { store([0x74u8, 0xedu8, 0x1fu8, 0xb9u8, 0xa9u8, 0xbfu8, 0x99u8, 0xd0u8, 0xb0u8, 0x2du8, 0xbeu8, 0xfeu8, 0x04u8, 0x24u8, 0x64u8, 0xcdu8, 0x71u8, 0x53u8, 0x01u8, 0x85u8, 0x9au8, 0x70u8, 0x33u8, 0x7au8, 0x99u8, 0x34u8, 0x4bu8, 0xe7u8, 0x62u8, 0xdcu8, 0xbeu8, 0x10u8]) } + fn int_neg_addr() -> Addr { store([0xf6u8, 0x1cu8, 0x7du8, 0x3fu8, 0xceu8, 0x59u8, 0x54u8, 0x30u8, 0xf8u8, 0x6fu8, 0x0cu8, 0xd5u8, 0x2du8, 0xa5u8, 0xbcu8, 0xb0u8, 0x0bu8, 0xf9u8, 0x10u8, 0xedu8, 0xd8u8, 0x5eu8, 0x14u8, 0xdcu8, 0x04u8, 0x02u8, 0x13u8, 0x0fu8, 0xccu8, 0xe3u8, 0x4eu8, 0xbdu8]) } + fn int_emod_addr() -> Addr { store([0xacu8, 0x9cu8, 0x72u8, 0x31u8, 0x95u8, 0x51u8, 0xf5u8, 0x63u8, 0x7fu8, 0x7cu8, 0x51u8, 0xc7u8, 0x0bu8, 0xe6u8, 0xdau8, 0x8fu8, 0xd6u8, 0x6au8, 0x81u8, 0x83u8, 0x7cu8, 0x9eu8, 0xb5u8, 0x0cu8, 0x3fu8, 0xd5u8, 0x0eu8, 0xcfu8, 0x8cu8, 0xbbu8, 0xc0u8, 0x70u8]) } + fn int_ediv_addr() -> Addr { store([0x9fu8, 0x2cu8, 0xa4u8, 0xe3u8, 0xdeu8, 0x3au8, 0x79u8, 0x4fu8, 0x67u8, 0xdbu8, 0x64u8, 0x84u8, 0x9du8, 0xd5u8, 0x77u8, 0xc0u8, 0x66u8, 0xe5u8, 0x61u8, 0x42u8, 0x20u8, 0x6fu8, 0xa6u8, 0xbcu8, 0x72u8, 0x4eu8, 0x4bu8, 0x8du8, 0xb6u8, 0xf2u8, 0x0fu8, 0x5bu8]) } + fn int_bmod_addr() -> Addr { store([0x19u8, 0x7du8, 0x3cu8, 0x7eu8, 0x9cu8, 0xe0u8, 0x94u8, 0x9cu8, 0x52u8, 0xefu8, 0x98u8, 0xf5u8, 0x0bu8, 0x58u8, 0xddu8, 0xb9u8, 0x42u8, 0xdbu8, 0x6du8, 0x36u8, 0x76u8, 0x40u8, 0xd6u8, 0xfbu8, 0x6fu8, 0x49u8, 0xabu8, 0x91u8, 0xf8u8, 0x2fu8, 0x42u8, 0x71u8]) } + fn int_bdiv_addr() -> Addr { store([0x07u8, 0x13u8, 0x40u8, 0x5au8, 0x68u8, 0x9du8, 0x21u8, 0x55u8, 0xa8u8, 0x41u8, 0x23u8, 0xa0u8, 0xf6u8, 0x39u8, 0x5cu8, 0x31u8, 0xc6u8, 0xfau8, 0x55u8, 0xc1u8, 0xadu8, 0x90u8, 0x5fu8, 0xc5u8, 0x56u8, 0x63u8, 0xacu8, 0xf7u8, 0xd7u8, 0x57u8, 0x7fu8, 0x57u8]) } + fn int_nat_abs_addr() -> Addr { store([0x83u8, 0xe3u8, 0xceu8, 0x8au8, 0x74u8, 0x75u8, 0x20u8, 0xccu8, 0x24u8, 0x8au8, 0x0du8, 0xacu8, 0xf9u8, 0xbdu8, 0x13u8, 0x69u8, 0x46u8, 0x7eu8, 0x49u8, 0x07u8, 0xe8u8, 0xaau8, 0xaau8, 0x43u8, 0x3eu8, 0x1bu8, 0x43u8, 0x8eu8, 0x1cu8, 0xadu8, 0x7cu8, 0xa4u8]) } + fn int_pow_addr() -> Addr { store([0x87u8, 0x5bu8, 0xe8u8, 0xd8u8, 0xaeu8, 0x5fu8, 0x33u8, 0x20u8, 0x03u8, 0xecu8, 0x2bu8, 0xadu8, 0xe6u8, 0x98u8, 0xbbu8, 0x0au8, 0xa5u8, 0xf2u8, 0xf4u8, 0x6eu8, 0x71u8, 0x21u8, 0x8du8, 0xa9u8, 0xcdu8, 0xd9u8, 0xd0u8, 0x95u8, 0x06u8, 0xe8u8, 0x4cu8, 0x10u8]) } + + fn nat_add_addr() -> Addr { store([0xe1u8, 0xeeu8, 0x4cu8, 0x78u8, 0xa3u8, 0x90u8, 0x64u8, 0x64u8, 0xfau8, 0x8cu8, 0x17u8, 0xecu8, 0x2eu8, 0xd0u8, 0xc0u8, 0xbfu8, @@ -1397,6 +1411,14 @@ def natPrim := ⟦ } } + fn is_int_prim_addr(a: Addr) -> G { + address_eq(a, int_add_addr()) + address_eq(a, int_sub_addr()) + + address_eq(a, int_mul_addr()) + address_eq(a, int_neg_addr()) + + address_eq(a, int_emod_addr()) + address_eq(a, int_ediv_addr()) + + address_eq(a, int_bmod_addr()) + address_eq(a, int_bdiv_addr()) + + address_eq(a, int_nat_abs_addr()) + address_eq(a, int_pow_addr()) + } + -- ============================================================================ -- Extract Nat literal from KExpr -- ============================================================================ @@ -1439,6 +1461,183 @@ def natPrim := ⟦ store(KExprNode.Lit(KLiteral.Nat(n))) } + -- Canonical Int literals are `Int.ofNat n` and `Int.negSucc n`. + -- Internally use (sign, absolute magnitude), with sign=1 negative. + fn try_extract_int_prim(e: KExpr) -> (G, G, KLimbs) { + match load(e) { + KExprNode.App(f, a) => match load(f) { + KExprNode.Const(caddr, _) => match try_extract_nat(a) { + (1, n) => match address_eq(caddr, int_of_nat_addr()) { + 1 => (1, 0, klimbs_normalize(n)), + _ => match address_eq(caddr, int_neg_succ_addr()) { + 1 => (1, 1, klimbs_normalize(klimbs_succ(n))), + _ => (0, 0, store(ListNode.Nil)), + }, + }, + _ => (0, 0, store(ListNode.Nil)), + }, + _ => (0, 0, store(ListNode.Nil)), + }, + _ => (0, 0, store(ListNode.Nil)), + } + } + + fn mk_int_prim(sign: G, magnitude: KLimbs) -> KExpr { + let mag = klimbs_normalize(magnitude); + let neg = sign * (1 - klimbs_is_zero(mag)); + let caddr = match neg { 0 => int_of_nat_addr(), _ => int_neg_succ_addr(), }; + let arg = match neg { 0 => mag, _ => klimbs_normalize(klimbs_dec(mag)), }; + store(KExprNode.App(store(KExprNode.Const(caddr, store(ListNode.Nil))), mk_nat_lit(arg))) + } + + fn int_add_prim(sa: G, a: KLimbs, sb: G, b: KLimbs) -> KExpr { + match sa - sb { + 0 => mk_int_prim(sa, klimbs_add(a, b)), + _ => match klimbs_le(a, b) { + 1 => mk_int_prim(sb, klimbs_sub(b, a)), + _ => mk_int_prim(sa, klimbs_sub(a, b)), + }, + } + } + + -- Euclidean quotient/remainder for signed a,b. Remainder is always + -- nonnegative and smaller than |b| (unless b=0, where r=a and q=0). + fn int_emod_prim(sa: G, a: KLimbs, b: KLimbs) -> KExpr { + match klimbs_is_zero(b) { + 1 => mk_int_prim(sa, a), + _ => + let r0 = klimbs_mod(a, b); + match sa * (1 - klimbs_is_zero(r0)) { + 1 => mk_int_prim(0, klimbs_sub(b, r0)), + _ => mk_int_prim(0, r0), + }, + } + } + + fn int_ediv_prim(sa: G, a: KLimbs, sb: G, b: KLimbs) -> KExpr { + match klimbs_is_zero(b) { + 1 => mk_int_prim(0, store(ListNode.Nil)), + _ => + let q0 = klimbs_div(a, b); + let r0 = klimbs_mod(a, b); + let q = match sa * (1 - klimbs_is_zero(r0)) { + 1 => klimbs_succ(q0), + _ => q0, + }; + mk_int_prim((sa + sb - 2 * sa * sb) * (1 - klimbs_is_zero(q)), q), + } + } + + fn int_bmod_prim(sa: G, a: KLimbs, m: KLimbs) -> KExpr { + match klimbs_is_zero(m) { + 1 => mk_int_prim(sa, a), + _ => + let r0 = klimbs_mod(a, m); + let r = match sa * (1 - klimbs_is_zero(r0)) { + 1 => klimbs_sub(m, r0), + _ => r0, + }; + let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); + let half = klimbs_div(klimbs_succ(m), two); + match klimbs_le(half, r) { + 1 => mk_int_prim(1, klimbs_sub(m, r)), + _ => mk_int_prim(0, r), + }, + } + } + + fn int_bdiv_prim(sa: G, a: KLimbs, m: KLimbs) -> KExpr { + match klimbs_is_zero(m) { + 1 => mk_int_prim(0, store(ListNode.Nil)), + _ => + let r0 = klimbs_mod(a, m); + let r = match sa * (1 - klimbs_is_zero(r0)) { + 1 => klimbs_sub(m, r0), + _ => r0, + }; + let q0 = klimbs_div(a, m); + let qmag = match sa * (1 - klimbs_is_zero(r0)) { 1 => klimbs_succ(q0), _ => q0, }; + let qsign = sa * (1 - klimbs_is_zero(qmag)); + let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); + let half = klimbs_div(klimbs_succ(m), two); + match klimbs_le(half, r) { + 0 => mk_int_prim(qsign, qmag), + _ => int_add_prim(qsign, qmag, 0, + store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil)))), + }, + } + } + + fn try_int_prim_dispatch(head_addr: Addr, spine: List‹KExpr›, + types: List‹KExpr›) -> (G, KExpr) { + let sw = whnf_spine(spine, types); + let n = list_length(sw); + let unary = address_eq(head_addr, int_neg_addr()) + address_eq(head_addr, int_nat_abs_addr()); + match unary { + 1 => match u32_less_than(n, 1) { + 1 => (0, store(KExprNode.BVar(0))), + _ => match try_extract_int_prim(list_lookup(sw, 0)) { + (1, s, a) => + let v = match address_eq(head_addr, int_nat_abs_addr()) { + 1 => mk_nat_lit(a), + _ => mk_int_prim((1 - s) * (1 - klimbs_is_zero(a)), a), + }; + (1, np_apply_spine(v, list_drop(sw, 1))), + _ => (0, store(KExprNode.BVar(0))), + }, + }, + _ => match u32_less_than(n, 2) { + 1 => (0, store(KExprNode.BVar(0))), + _ => match try_extract_int_prim(list_lookup(sw, 0)) { + (1, sa, a) => try_int_prim_second(head_addr, sw, sa, a), + _ => (0, store(KExprNode.BVar(0))), + }, + }, + } + } + + fn try_int_prim_second(head_addr: Addr, sw: List‹KExpr›, + sa: G, a: KLimbs) -> (G, KExpr) { + let rhs_nat = address_eq(head_addr, int_bmod_addr()) + + address_eq(head_addr, int_bdiv_addr()) + address_eq(head_addr, int_pow_addr()); + match rhs_nat { + 1 => match try_extract_nat(list_lookup(sw, 1)) { + (1, b) => + let v = match address_eq(head_addr, int_bmod_addr()) { + 1 => int_bmod_prim(sa, a, b), + _ => match address_eq(head_addr, int_bdiv_addr()) { + 1 => int_bdiv_prim(sa, a, b), + _ => + let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); + let odd = 1 - klimbs_is_zero(klimbs_mod(b, two)); + mk_int_prim(sa * odd, klimbs_pow(a, b)), + }, + }; + (1, np_apply_spine(v, list_drop(sw, 2))), + _ => (0, store(KExprNode.BVar(0))), + }, + _ => match try_extract_int_prim(list_lookup(sw, 1)) { + (1, sb, b) => + let v = match address_eq(head_addr, int_add_addr()) { + 1 => int_add_prim(sa, a, sb, b), + _ => match address_eq(head_addr, int_sub_addr()) { + 1 => int_add_prim(sa, a, (1 - sb) * (1 - klimbs_is_zero(b)), b), + _ => match address_eq(head_addr, int_mul_addr()) { + 1 => mk_int_prim((sa + sb - 2 * sa * sb) + * (1 - klimbs_is_zero(a)) * (1 - klimbs_is_zero(b)), klimbs_mul(a, b)), + _ => match address_eq(head_addr, int_emod_addr()) { + 1 => int_emod_prim(sa, a, b), + _ => int_ediv_prim(sa, a, sb, b), + }, + }, + }, + }; + (1, np_apply_spine(v, list_drop(sw, 2))), + _ => (0, store(KExprNode.BVar(0))), + }, + } + } + -- ============================================================================ -- Apply spine (rebuild App chain). -- ============================================================================ diff --git a/Ix/IxVM/Kernel/Whnf.lean b/Ix/IxVM/Kernel/Whnf.lean index e3b384ae..5a97cdc4 100644 --- a/Ix/IxVM/Kernel/Whnf.lean +++ b/Ix/IxVM/Kernel/Whnf.lean @@ -311,7 +311,7 @@ def whnf := ⟦ -- Primitive-family classification (mirror prim_family, -- Primitive.lean:1419): map a Const-head address to the ONE reducer -- family that could fire on it — 0 = none, 1 = nat, 2 = str, - -- 3 = bitvec, 4 = native, 5 = decidable. Keyed on the ADDRESS ALONE: + -- 3 = bitvec, 4 = native, 5 = decidable, 6 = Int. Keyed on the ADDRESS ALONE: -- one memo row per distinct constant address in the run, and the -- inner addr-set chains collapse after each address's first -- occurrence. Replaces running the is_* gauntlet from @@ -332,7 +332,7 @@ def whnf := ⟦ _ => match is_dec_prim_addr(a) { 1 => 5, - _ => 0, + _ => match is_int_prim_addr(a) { 1 => 6, _ => 0, }, }, }, }, @@ -352,6 +352,7 @@ def whnf := ⟦ 3 => try_bitvec_dispatch(addr, spine, types), 4 => try_native_dispatch(addr, spine, types), 5 => try_dec_dispatch(addr, lvls, spine, types), + 6 => try_int_prim_dispatch(addr, spine, types), _ => (0, store(KExprNode.BVar(0))), } } From 35f009c2976236d1c9ad4ce981b928dbc11333a6 Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Thu, 20 Aug 2026 16:34:12 +0000 Subject: [PATCH 4/5] perf(ixvm): compare projection applications structurally After bounded lazy reduction, compare application trees before falling back to eager WHNF. Recognize applications with identical projection heads and compare only their arguments, while descending through application nodes without resetting the def-eq reduction budget. This avoids pathological eager reduction of projection-heavy proof terms while preserving the existing fallback for unrelated shapes. Validated with a complete 600-shard sweep across Init, InitStd, Lean, Batteries, Mathlib, and FLT (24 workers, five-minute shard timeout): all shards passed. --- Ix/IxVM/Kernel/DefEq.lean | 54 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 53 insertions(+), 1 deletion(-) diff --git a/Ix/IxVM/Kernel/DefEq.lean b/Ix/IxVM/Kernel/DefEq.lean index 15bbaa8c..01b927c5 100644 --- a/Ix/IxVM/Kernel/DefEq.lean +++ b/Ix/IxVM/Kernel/DefEq.lean @@ -443,7 +443,59 @@ def defEq := ⟦ types: List‹KExpr›) -> G { match k_is_def_eq_struct_bounded(fa, fb, 8, types) { (1, _) => 1, - _ => slow2_eager_fallback(orig_a, orig_b, types), + _ => match k_is_def_eq_structure_tree(fa, fb, types) { + 1 => 1, + _ => slow2_eager_fallback(orig_a, orig_b, types), + }, + } + } + + fn try_same_proj_head_app(a: KExpr, b: KExpr, + types: List‹KExpr›) -> G { + let (ah, aa) = collect_spine(a); + let (bh, ba) = collect_spine(b); + match list_length(aa) { + 0 => 0, + _ => match list_length(aa) - list_length(ba) { + 0 => match load(ah) { + KExprNode.Proj(sa, ia, ea) => match load(bh) { + KExprNode.Proj(sb, ib, eb) => + match address_eq(sa, sb) * eq_zero(ia - ib) + * eq_zero(ptr_val(ea) - ptr_val(eb)) { + 1 => de_args(aa, ba, types), + _ => 0, + }, + _ => 0, + }, + _ => 0, + }, + _ => 0, + }, + } + } + + fn k_is_def_eq_structure_tree(a: KExpr, b: KExpr, + types: List‹KExpr›) -> G { + match k_is_def_eq_struct_bounded(a, b, 8, types) { + (1, _) => 1, + _ => match try_same_proj_head_app(a, b, types) { + 1 => 1, + _ => k_is_def_eq_structure_tree_app(a, b, types), + }, + } + } + + fn k_is_def_eq_structure_tree_app(a: KExpr, b: KExpr, + types: List‹KExpr›) -> G { + match load(a) { + KExprNode.App(af, ax) => match load(b) { + KExprNode.App(bf, bx) => match k_is_def_eq_structure_tree(af, bf, types) { + 1 => k_is_def_eq_structure_tree(ax, bx, types), + _ => 0, + }, + _ => 0, + }, + _ => 0, } } From 1e7b706c3a506fcaba4aa317279b1bbee5cb09af Mon Sep 17 00:00:00 2001 From: Arthur Paulino Date: Thu, 20 Aug 2026 14:51:44 -0700 Subject: [PATCH 5/5] test(ixvm): regen codegen and repin FFT costs Repin 77 kernel pins and shard pipeline pin from full `lake test -- --ignored ixvm` run after `ix codegen` regen. --- Tests/Ix/IxVM.lean | 154 +- Tests/Main.lean | 4 +- crates/ixvm-codegen/src/aiur_ixvm.rs | 23250 ++++++++++++++----------- 3 files changed, 12761 insertions(+), 10647 deletions(-) diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index 704c8c6f..6a0b7867 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -344,83 +344,83 @@ private def nameOfString (str : String) : Lean.Name := and an improvement has to be acknowledged by re-pinning. -/ private def kernelCheckEntries : List (String × Nat) := [ ("HEq", 129_401_040), - ("HEq.rec", 133_078_670), - ("Eq.rec", 132_487_222), - ("Nat", 129_394_264), - ("Nat.add", 165_316_967), - ("Nat.add_comm", 303_183_527), - ("Nat.decEq", 356_801_211), - ("Nat.decLe", 759_914_016), - ("Nat.sub_le_of_le_add", 1_857_586_334), - ("Nat.shiftRight_succ", 1_373_501_832), - ("Trans.mk", 135_307_735), - ("Array.append_assoc", 8_949_602_493), - ("Vector.append", 9_145_853_594), - ("IxVMPrim.nat_add_lit", 203_580_473), - ("IxVMPrim.nat_sub_lit", 218_126_720), - ("IxVMPrim.nat_mul_lit", 195_851_965), - ("IxVMPrim.nat_mul_big", 194_387_314), - ("IxVMPrim.nat_div_lit", 1_342_479_996), - ("IxVMPrim.nat_mod_lit", 1_368_017_506), - ("IxVMPrim.nat_succ_lit", 142_774_597), - ("IxVMPrim.nat_pred_lit", 162_346_216), - ("IxVMPrim.nat_gcd_lit", 2_110_290_155), - ("IxVMPrim.nat_land_lit", 3_492_236_898), - ("IxVMPrim.nat_lor_lit", 3_494_060_994), - ("IxVMPrim.nat_xor_lit", 3_512_377_000), - ("IxVMPrim.nat_shl_lit", 222_683_239), - ("IxVMPrim.nat_shr_lit", 1_356_479_286), - ("IxVMPrim.nat_pow_big", 382_730_051), - ("IxVMPrim.nat_beq_lit", 194_385_328), - ("IxVMPrim.nat_ble_lit", 188_996_930), - ("IxVMPrim.nat_cases_big", 162_176_527), - ("IxVMPrim.nat_dec_le", 776_957_622), - ("IxVMPrim.nat_dec_lt", 787_807_304), - ("IxVMPrim.nat_dec_eq", 393_477_089), - ("IxVMPrim.str_size_lit", 2_416_513_192), - ("IxVMPrim.bv_to_nat_lit", 2_011_463_297), - ("IxVMInd.Even", 197_591_495), - ("IxVMInd.Odd", 197_594_091), - ("IxVMInd.Even.rec", 214_461_662), - ("IxVMInd.Odd.rec", 214_459_813), - ("IxVMInd.IdxTeleN.rec", 156_973_564), - ("IxVMInd.IdxTeleB.rec", 156_972_722), - ("IxVMInd.SoloA.rec", 152_570_202), - ("IxVMInd.SoloB.rec", 152_570_202), - ("IxVMInd.UnsafeSquash", 131_117_457), - ("IxVMInd.Tree", 130_703_546), - ("IxVMInd.Tree.rec", 139_660_099), - ("IxVMInd.DedupM", 133_702_359), - ("IxVMInd.DedupM.rec", 145_825_072), - ("IxVMInd.DepthM", 132_257_976), - ("IxVMInd.DepthM.rec", 142_488_980), - ("String.Internal.append", 2_388_040_428), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_562_630_202), - ("Lean.Syntax.rec", 2_442_191_008), - ("IxVMInd.AuxTie", 304_967_577), - ("IxVMInd.AuxTie.rec", 344_891_121), - ("IxVMInd.HiddenIdx", 129_941_958), - ("IxVMInd.HiddenIdx.rec", 132_439_643), - ("IxVMInd.thmMajorUse", 487_904_488), - ("IxVMInd.partialKRec", 147_850_631), - ("IxVMInd.deepRebase", 210_265_145), - ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec", 3_316_224_986), - ("Lean.Widget.TaggedText.rec", 2_415_068_912), - ("Lean.Doc.Part.rec", 2_453_998_515), - ("Lean.Doc.Block.rec", 2_673_557_734), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 131_940_408), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 134_739_065), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 134_161_618), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 134_161_618), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 134_161_618), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_138_701), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 142_226_210), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 142_224_636), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 134_161_618), - ("strOfListFoldSize", 2_688_551_020), - ("strOfListFoldSizeAscii", 2_689_322_165), - ("IxVMPrim.lazy_ble_offset", 223_080_952), - ("IxVMPrim.lazy_unit_cast", 523_704_702), + ("HEq.rec", 133_148_512), + ("Eq.rec", 132_535_244), + ("Nat", 129_438_584), + ("Nat.add", 166_225_532), + ("Nat.add_comm", 308_457_475), + ("Nat.decEq", 364_638_853), + ("Nat.decLe", 777_229_532), + ("Nat.sub_le_of_le_add", 1_896_516_418), + ("Nat.shiftRight_succ", 1_404_793_386), + ("Trans.mk", 135_383_805), + ("Array.append_assoc", 9_070_739_205), + ("Vector.append", 9_269_843_706), + ("IxVMPrim.nat_add_lit", 205_587_450), + ("IxVMPrim.nat_sub_lit", 220_246_949), + ("IxVMPrim.nat_mul_lit", 197_091_263), + ("IxVMPrim.nat_mul_big", 195_620_487), + ("IxVMPrim.nat_div_lit", 1_371_606_999), + ("IxVMPrim.nat_mod_lit", 1_397_464_597), + ("IxVMPrim.nat_succ_lit", 143_056_464), + ("IxVMPrim.nat_pred_lit", 162_882_946), + ("IxVMPrim.nat_gcd_lit", 2_157_471_570), + ("IxVMPrim.nat_land_lit", 3_557_993_290), + ("IxVMPrim.nat_lor_lit", 3_559_819_986), + ("IxVMPrim.nat_xor_lit", 3_578_368_535), + ("IxVMPrim.nat_shl_lit", 224_281_532), + ("IxVMPrim.nat_shr_lit", 1_385_626_324), + ("IxVMPrim.nat_pow_big", 385_807_614), + ("IxVMPrim.nat_beq_lit", 195_813_453), + ("IxVMPrim.nat_ble_lit", 190_326_816), + ("IxVMPrim.nat_cases_big", 163_037_161), + ("IxVMPrim.nat_dec_le", 794_753_434), + ("IxVMPrim.nat_dec_lt", 805_826_434), + ("IxVMPrim.nat_dec_eq", 402_422_679), + ("IxVMPrim.str_size_lit", 2_468_609_203), + ("IxVMPrim.bv_to_nat_lit", 2_058_943_633), + ("IxVMInd.Even", 198_963_024), + ("IxVMInd.Odd", 198_965_621), + ("IxVMInd.Even.rec", 215_995_195), + ("IxVMInd.Odd.rec", 215_994_271), + ("IxVMInd.IdxTeleN.rec", 157_255_988), + ("IxVMInd.IdxTeleB.rec", 157_255_146), + ("IxVMInd.SoloA.rec", 152_850_190), + ("IxVMInd.SoloB.rec", 152_850_190), + ("IxVMInd.UnsafeSquash", 131_117_557), + ("IxVMInd.Tree", 130_802_963), + ("IxVMInd.Tree.rec", 139_790_913), + ("IxVMInd.DedupM", 133_837_112), + ("IxVMInd.DedupM.rec", 145_992_467), + ("IxVMInd.DepthM", 132_388_056), + ("IxVMInd.DepthM.rec", 142_682_129), + ("String.Internal.append", 2_439_897_505), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_636_655_453), + ("Lean.Syntax.rec", 2_494_352_709), + ("IxVMInd.AuxTie", 307_684_302), + ("IxVMInd.AuxTie.rec", 347_798_352), + ("IxVMInd.HiddenIdx", 129_987_097), + ("IxVMInd.HiddenIdx.rec", 132_516_236), + ("IxVMInd.thmMajorUse", 498_291_604), + ("IxVMInd.partialKRec", 148_528_671), + ("IxVMInd.deepRebase", 212_996_576), + ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec", 3_401_124_861), + ("Lean.Widget.TaggedText.rec", 2_467_059_285), + ("Lean.Doc.Part.rec", 2_506_906_864), + ("Lean.Doc.Block.rec", 2_726_901_380), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 131_985_878), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 134_785_783), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 134_230_554), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 134_230_554), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 134_230_554), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_238_939), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 142_358_345), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 142_356_772), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 134_230_554), + ("strOfListFoldSize", 2_744_277_864), + ("strOfListFoldSizeAscii", 2_745_050_429), + ("IxVMPrim.lazy_ble_offset", 225_108_246), + ("IxVMPrim.lazy_unit_cast", 534_750_477), ] /-- Variant of `kernelChecks`, pinned to the baseline diff --git a/Tests/Main.lean b/Tests/Main.lean index 3e1f4450..1e82760b 100644 --- a/Tests/Main.lean +++ b/Tests/Main.lean @@ -277,8 +277,8 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [ let actual := (Aiur.computeStats v2Env.compiled qc v2Env.shapes).totalFftCost.round.toUInt64.toNat pure (LSpec.test - s!"Shard pipeline FFT matches: expected 6_720_706_901, got {actual}" - (actual = 6_720_706_901)) + s!"Shard pipeline FFT matches: expected 6_770_109_972, got {actual}" + (actual = 6_770_109_972)) LSpec.lspecIO (.ofList [("ixvm", [fullSeq, aiurSeq, arenaSeq, exploitSeq, paritySeq, shardSeq])]) []), diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs index 2ef2007a..9c2a3f3e 100644 --- a/crates/ixvm-codegen/src/aiur_ixvm.rs +++ b/crates/ixvm-codegen/src/aiur_ixvm.rs @@ -5210,7 +5210,7 @@ fn aiur_fn_28( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_74: G = __loaded[0]; @@ -5391,10 +5391,10 @@ fn aiur_fn_28( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[772].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_772(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_772] = unsafe { *(result.output.as_ptr() as *const [G; OUT_772]) }; __ret } } else { aiur_fn_772(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_76: G = __loaded[0]; @@ -7929,7 +7929,7 @@ fn aiur_fn_33( return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -7950,7 +7950,7 @@ fn aiur_fn_33( return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -9931,7 +9931,7 @@ fn aiur_fn_57( 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_744] = { let __args: [G; IN_744] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -10294,7 +10294,7 @@ fn aiur_fn_62( let __v_43: G = __loaded[15]; let __v_44: G = __loaded[16]; let __v_45: G = __loaded[17]; - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; let __v_48: G = __r_arr[2]; @@ -10711,7 +10711,7 @@ fn aiur_fn_68( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10742,7 +10742,7 @@ fn aiur_fn_69( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10773,7 +10773,7 @@ fn aiur_fn_70( stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -10861,7 +10861,7 @@ fn aiur_fn_71( let __v_51: G = __r_arr[0]; match __v_0.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -14207,7 +14207,7 @@ fn aiur_fn_111( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __ret: [G; OUT_111] = [__v_5, __v_7]; if let Some(result) = record.function_queries[111].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -15657,7 +15657,7 @@ fn aiur_fn_127( return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__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[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __ret: [G; OUT_127] = [__v_29]; if let Some(result) = record.function_queries[127].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; @@ -15713,7 +15713,7 @@ fn aiur_fn_127( 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_752] = { let __args: [G; IN_752] = [__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[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_17, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__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[127].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_127(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; @@ -16624,6 +16624,594 @@ fn aiur_fn_146( io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_146], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(9); + let __v_1: G = G::from_u64(188); + let __v_2: G = G::from_u64(37); + let __v_3: G = G::from_u64(49); + let __v_4: G = G::from_u64(71); + let __v_5: G = G::from_u64(195); + let __v_6: G = G::from_u64(108); + let __v_7: G = G::from_u64(226); + let __v_8: G = G::from_u64(44); + let __v_9: G = G::from_u64(142); + let __v_10: G = G::from_u64(12); + let __v_11: G = G::from_u64(205); + let __v_12: G = G::from_u64(67); + let __v_13: G = G::from_u64(199); + let __v_14: G = G::from_u64(155); + let __v_15: G = G::from_u64(44); + let __v_16: G = G::from_u64(218); + let __v_17: G = G::from_u64(226); + let __v_18: G = G::from_u64(32); + let __v_19: G = G::from_u64(110); + let __v_20: G = G::from_u64(13); + let __v_21: G = G::from_u64(221); + let __v_22: G = G::from_u64(22); + let __v_23: G = G::from_u64(143); + let __v_24: G = G::from_u64(202); + let __v_25: G = G::from_u64(54); + let __v_26: G = G::from_u64(9); + let __v_27: G = G::from_u64(178); + let __v_28: G = G::from_u64(165); + let __v_29: G = G::from_u64(132); + let __v_30: G = G::from_u64(211); + let __v_31: G = G::from_u64(220); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_146] = [__v_32]; + if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_147: usize = 0; +const IN_147: usize = 0; +const OUT_147: usize = 1; +fn aiur_fn_147( + inp: [G; IN_147], + 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 = G::from_u64(38); + let __v_1: G = G::from_u64(124); + let __v_2: G = G::from_u64(10); + let __v_3: G = G::from_u64(156); + let __v_4: G = G::from_u64(146); + let __v_5: G = G::from_u64(231); + let __v_6: G = G::from_u64(86); + let __v_7: G = G::from_u64(56); + let __v_8: G = G::from_u64(252); + let __v_9: G = G::from_u64(115); + let __v_10: G = G::from_u64(237); + let __v_11: G = G::from_u64(82); + let __v_12: G = G::from_u64(169); + let __v_13: G = G::from_u64(249); + let __v_14: G = G::from_u64(200); + let __v_15: G = G::from_u64(22); + let __v_16: G = G::from_u64(71); + let __v_17: G = G::from_u64(238); + let __v_18: G = G::from_u64(236); + let __v_19: G = G::from_u64(238); + let __v_20: G = G::from_u64(255); + let __v_21: G = G::from_u64(33); + let __v_22: G = G::from_u64(68); + let __v_23: G = G::from_u64(193); + let __v_24: G = G::from_u64(249); + let __v_25: G = G::from_u64(126); + let __v_26: G = G::from_u64(101); + let __v_27: G = G::from_u64(226); + let __v_28: G = G::from_u64(175); + let __v_29: G = G::from_u64(241); + let __v_30: G = G::from_u64(73); + let __v_31: G = G::from_u64(241); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_147] = [__v_32]; + if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_148: usize = 0; +const IN_148: usize = 0; +const OUT_148: usize = 1; +fn aiur_fn_148( + inp: [G; IN_148], + 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 = G::from_u64(182); + let __v_1: G = G::from_u64(187); + let __v_2: G = G::from_u64(172); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(200); + let __v_5: G = G::from_u64(228); + let __v_6: G = G::from_u64(111); + let __v_7: G = G::from_u64(139); + let __v_8: G = G::from_u64(134); + let __v_9: G = G::from_u64(64); + let __v_10: G = G::from_u64(41); + let __v_11: G = G::from_u64(143); + let __v_12: G = G::from_u64(76); + let __v_13: G = G::from_u64(154); + let __v_14: G = G::from_u64(200); + let __v_15: G = G::from_u64(148); + let __v_16: G = G::from_u64(203); + let __v_17: G = G::from_u64(205); + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(3); + let __v_21: G = G::from_u64(94); + let __v_22: G = G::from_u64(221); + let __v_23: G = G::from_u64(84); + let __v_24: G = G::from_u64(63); + let __v_25: G = G::from_u64(124); + let __v_26: G = G::from_u64(67); + let __v_27: G = G::from_u64(78); + let __v_28: G = G::from_u64(44); + let __v_29: G = G::from_u64(159); + let __v_30: G = G::from_u64(233); + let __v_31: G = G::from_u64(38); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_148] = [__v_32]; + if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_149: usize = 0; +const IN_149: usize = 0; +const OUT_149: usize = 1; +fn aiur_fn_149( + inp: [G; IN_149], + 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 = G::from_u64(188); + let __v_1: G = G::from_u64(176); + let __v_2: G = G::from_u64(155); + let __v_3: G = G::from_u64(164); + let __v_4: G = G::from_u64(63); + let __v_5: G = G::from_u64(139); + let __v_6: G = G::from_u64(218); + let __v_7: G = G::from_u64(230); + let __v_8: G = G::from_u64(92); + let __v_9: G = G::from_u64(86); + let __v_10: G = G::from_u64(164); + let __v_11: G = G::from_u64(127); + let __v_12: G = G::from_u64(247); + let __v_13: G = G::from_u64(123); + let __v_14: G = G::from_u64(80); + let __v_15: G = G::from_u64(180); + let __v_16: G = G::from_u64(46); + let __v_17: G = G::from_u64(222); + let __v_18: G = G::from_u64(18); + let __v_19: G = G::from_u64(15); + let __v_20: G = G::from_u64(188); + let __v_21: G = G::from_u64(219); + let __v_22: G = G::from_u64(168); + let __v_23: G = G::from_u64(70); + let __v_24: G = G::from_u64(158); + let __v_25: G = G::from_u64(121); + let __v_26: G = G::from_u64(154); + let __v_27: G = G::from_u64(33); + let __v_28: G = G::from_u64(241); + let __v_29: G = G::from_u64(47); + let __v_30: G = G::from_u64(211); + let __v_31: G = G::from_u64(137); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_32]; + if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_150: usize = 0; +const IN_150: usize = 0; +const OUT_150: usize = 1; +fn aiur_fn_150( + inp: [G; IN_150], + 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 = G::from_u64(116); + let __v_1: G = G::from_u64(237); + let __v_2: G = G::from_u64(31); + let __v_3: G = G::from_u64(185); + let __v_4: G = G::from_u64(169); + let __v_5: G = G::from_u64(191); + let __v_6: G = G::from_u64(153); + let __v_7: G = G::from_u64(208); + let __v_8: G = G::from_u64(176); + let __v_9: G = G::from_u64(45); + let __v_10: G = G::from_u64(190); + let __v_11: G = G::from_u64(254); + let __v_12: G = G::from_u64(4); + let __v_13: G = G::from_u64(36); + let __v_14: G = G::from_u64(100); + let __v_15: G = G::from_u64(205); + let __v_16: G = G::from_u64(113); + let __v_17: G = G::from_u64(83); + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(133); + let __v_20: G = G::from_u64(154); + let __v_21: G = G::from_u64(112); + let __v_22: G = G::from_u64(51); + let __v_23: G = G::from_u64(122); + let __v_24: G = G::from_u64(153); + let __v_25: G = G::from_u64(52); + let __v_26: G = G::from_u64(75); + let __v_27: G = G::from_u64(231); + let __v_28: G = G::from_u64(98); + let __v_29: G = G::from_u64(220); + let __v_30: G = G::from_u64(190); + let __v_31: G = G::from_u64(16); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_150] = [__v_32]; + if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_151: usize = 0; +const IN_151: usize = 0; +const OUT_151: usize = 1; +fn aiur_fn_151( + inp: [G; IN_151], + 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 = G::from_u64(246); + let __v_1: G = G::from_u64(28); + let __v_2: G = G::from_u64(125); + let __v_3: G = G::from_u64(63); + let __v_4: G = G::from_u64(206); + let __v_5: G = G::from_u64(89); + let __v_6: G = G::from_u64(84); + let __v_7: G = G::from_u64(48); + let __v_8: G = G::from_u64(248); + let __v_9: G = G::from_u64(111); + let __v_10: G = G::from_u64(12); + let __v_11: G = G::from_u64(213); + let __v_12: G = G::from_u64(45); + let __v_13: G = G::from_u64(165); + let __v_14: G = G::from_u64(188); + let __v_15: G = G::from_u64(176); + let __v_16: G = G::from_u64(11); + let __v_17: G = G::from_u64(249); + let __v_18: G = G::from_u64(16); + let __v_19: G = G::from_u64(237); + let __v_20: G = G::from_u64(216); + let __v_21: G = G::from_u64(94); + let __v_22: G = G::from_u64(20); + let __v_23: G = G::from_u64(220); + let __v_24: G = G::from_u64(4); + let __v_25: G = G::from_u64(2); + let __v_26: G = G::from_u64(19); + let __v_27: G = G::from_u64(15); + let __v_28: G = G::from_u64(204); + let __v_29: G = G::from_u64(227); + let __v_30: G = G::from_u64(78); + let __v_31: G = G::from_u64(189); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_151] = [__v_32]; + if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_152: usize = 0; +const IN_152: usize = 0; +const OUT_152: usize = 1; +fn aiur_fn_152( + inp: [G; IN_152], + 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 = G::from_u64(172); + let __v_1: G = G::from_u64(156); + let __v_2: G = G::from_u64(114); + let __v_3: G = G::from_u64(49); + let __v_4: G = G::from_u64(149); + let __v_5: G = G::from_u64(81); + let __v_6: G = G::from_u64(245); + let __v_7: G = G::from_u64(99); + let __v_8: G = G::from_u64(127); + let __v_9: G = G::from_u64(124); + let __v_10: G = G::from_u64(81); + let __v_11: G = G::from_u64(199); + let __v_12: G = G::from_u64(11); + let __v_13: G = G::from_u64(230); + let __v_14: G = G::from_u64(218); + let __v_15: G = G::from_u64(143); + let __v_16: G = G::from_u64(214); + let __v_17: G = G::from_u64(106); + let __v_18: G = G::from_u64(129); + let __v_19: G = G::from_u64(131); + let __v_20: G = G::from_u64(124); + let __v_21: G = G::from_u64(158); + let __v_22: G = G::from_u64(181); + let __v_23: G = G::from_u64(12); + let __v_24: G = G::from_u64(63); + let __v_25: G = G::from_u64(213); + let __v_26: G = G::from_u64(14); + let __v_27: G = G::from_u64(207); + let __v_28: G = G::from_u64(140); + let __v_29: G = G::from_u64(187); + let __v_30: G = G::from_u64(192); + let __v_31: G = G::from_u64(112); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_152] = [__v_32]; + if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_153: usize = 0; +const IN_153: usize = 0; +const OUT_153: usize = 1; +fn aiur_fn_153( + inp: [G; IN_153], + 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 = G::from_u64(159); + let __v_1: G = G::from_u64(44); + let __v_2: G = G::from_u64(164); + let __v_3: G = G::from_u64(227); + let __v_4: G = G::from_u64(222); + let __v_5: G = G::from_u64(58); + let __v_6: G = G::from_u64(121); + let __v_7: G = G::from_u64(79); + let __v_8: G = G::from_u64(103); + let __v_9: G = G::from_u64(219); + let __v_10: G = G::from_u64(100); + let __v_11: G = G::from_u64(132); + let __v_12: G = G::from_u64(157); + let __v_13: G = G::from_u64(213); + let __v_14: G = G::from_u64(119); + let __v_15: G = G::from_u64(192); + let __v_16: G = G::from_u64(102); + let __v_17: G = G::from_u64(229); + let __v_18: G = G::from_u64(97); + let __v_19: G = G::from_u64(66); + let __v_20: G = G::from_u64(32); + let __v_21: G = G::from_u64(111); + let __v_22: G = G::from_u64(166); + let __v_23: G = G::from_u64(188); + let __v_24: G = G::from_u64(114); + let __v_25: G = G::from_u64(78); + let __v_26: G = G::from_u64(75); + let __v_27: G = G::from_u64(141); + let __v_28: G = G::from_u64(182); + let __v_29: G = G::from_u64(242); + let __v_30: G = G::from_u64(15); + let __v_31: G = G::from_u64(91); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_153] = [__v_32]; + if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_154: usize = 0; +const IN_154: usize = 0; +const OUT_154: usize = 1; +fn aiur_fn_154( + inp: [G; IN_154], + 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 = G::from_u64(25); + let __v_1: G = G::from_u64(125); + let __v_2: G = G::from_u64(60); + let __v_3: G = G::from_u64(126); + let __v_4: G = G::from_u64(156); + let __v_5: G = G::from_u64(224); + let __v_6: G = G::from_u64(148); + let __v_7: G = G::from_u64(156); + let __v_8: G = G::from_u64(82); + let __v_9: G = G::from_u64(239); + let __v_10: G = G::from_u64(152); + let __v_11: G = G::from_u64(245); + let __v_12: G = G::from_u64(11); + let __v_13: G = G::from_u64(88); + let __v_14: G = G::from_u64(221); + let __v_15: G = G::from_u64(185); + let __v_16: G = G::from_u64(66); + let __v_17: G = G::from_u64(219); + let __v_18: G = G::from_u64(109); + let __v_19: G = G::from_u64(54); + let __v_20: G = G::from_u64(118); + let __v_21: G = G::from_u64(64); + let __v_22: G = G::from_u64(214); + let __v_23: G = G::from_u64(251); + let __v_24: G = G::from_u64(111); + let __v_25: G = G::from_u64(73); + let __v_26: G = G::from_u64(171); + let __v_27: G = G::from_u64(145); + let __v_28: G = G::from_u64(248); + let __v_29: G = G::from_u64(47); + let __v_30: G = G::from_u64(66); + let __v_31: G = G::from_u64(113); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_154] = [__v_32]; + if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_155: usize = 0; +const IN_155: usize = 0; +const OUT_155: usize = 1; +fn aiur_fn_155( + inp: [G; IN_155], + 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 = G::from_u64(7); + let __v_1: G = G::from_u64(19); + let __v_2: G = G::from_u64(64); + let __v_3: G = G::from_u64(90); + let __v_4: G = G::from_u64(104); + let __v_5: G = G::from_u64(157); + let __v_6: G = G::from_u64(33); + let __v_7: G = G::from_u64(85); + let __v_8: G = G::from_u64(168); + let __v_9: G = G::from_u64(65); + let __v_10: G = G::from_u64(35); + let __v_11: G = G::from_u64(160); + let __v_12: G = G::from_u64(246); + let __v_13: G = G::from_u64(57); + let __v_14: G = G::from_u64(92); + let __v_15: G = G::from_u64(49); + let __v_16: G = G::from_u64(198); + let __v_17: G = G::from_u64(250); + let __v_18: G = G::from_u64(85); + let __v_19: G = G::from_u64(193); + let __v_20: G = G::from_u64(173); + let __v_21: G = G::from_u64(144); + let __v_22: G = G::from_u64(95); + let __v_23: G = G::from_u64(197); + let __v_24: G = G::from_u64(86); + let __v_25: G = G::from_u64(99); + let __v_26: G = G::from_u64(172); + let __v_27: G = G::from_u64(247); + let __v_28: G = G::from_u64(215); + let __v_29: G = G::from_u64(87); + let __v_30: G = G::from_u64(127); + let __v_31: G = G::from_u64(87); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_155] = [__v_32]; + if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_156: usize = 0; +const IN_156: usize = 0; +const OUT_156: usize = 1; +fn aiur_fn_156( + inp: [G; IN_156], + 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 = G::from_u64(131); + let __v_1: G = G::from_u64(227); + let __v_2: G = G::from_u64(206); + let __v_3: G = G::from_u64(138); + let __v_4: G = G::from_u64(116); + let __v_5: G = G::from_u64(117); + let __v_6: G = G::from_u64(32); + let __v_7: G = G::from_u64(204); + let __v_8: G = G::from_u64(36); + let __v_9: G = G::from_u64(138); + let __v_10: G = G::from_u64(13); + let __v_11: G = G::from_u64(172); + let __v_12: G = G::from_u64(249); + let __v_13: G = G::from_u64(189); + let __v_14: G = G::from_u64(19); + let __v_15: G = G::from_u64(105); + let __v_16: G = G::from_u64(70); + let __v_17: G = G::from_u64(126); + let __v_18: G = G::from_u64(73); + let __v_19: G = G::from_u64(7); + let __v_20: G = G::from_u64(232); + let __v_21: G = G::from_u64(170); + let __v_22: G = G::from_u64(170); + let __v_23: G = G::from_u64(67); + let __v_24: G = G::from_u64(62); + let __v_25: G = G::from_u64(27); + let __v_26: G = G::from_u64(67); + let __v_27: G = G::from_u64(142); + let __v_28: G = G::from_u64(28); + let __v_29: G = G::from_u64(173); + let __v_30: G = G::from_u64(124); + let __v_31: G = G::from_u64(164); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_156] = [__v_32]; + if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_157: usize = 0; +const IN_157: usize = 0; +const OUT_157: usize = 1; +fn aiur_fn_157( + inp: [G; IN_157], + 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 = G::from_u64(135); + let __v_1: G = G::from_u64(91); + let __v_2: G = G::from_u64(232); + let __v_3: G = G::from_u64(216); + let __v_4: G = G::from_u64(174); + let __v_5: G = G::from_u64(95); + let __v_6: G = G::from_u64(51); + let __v_7: G = G::from_u64(32); + let __v_8: G = G::from_u64(3); + let __v_9: G = G::from_u64(236); + let __v_10: G = G::from_u64(43); + let __v_11: G = G::from_u64(173); + let __v_12: G = G::from_u64(230); + let __v_13: G = G::from_u64(152); + let __v_14: G = G::from_u64(187); + let __v_15: G = G::from_u64(10); + let __v_16: G = G::from_u64(165); + let __v_17: G = G::from_u64(242); + let __v_18: G = G::from_u64(244); + let __v_19: G = G::from_u64(110); + let __v_20: G = G::from_u64(113); + let __v_21: G = G::from_u64(33); + let __v_22: G = G::from_u64(141); + let __v_23: G = G::from_u64(169); + let __v_24: G = G::from_u64(205); + let __v_25: G = G::from_u64(217); + let __v_26: G = G::from_u64(208); + let __v_27: G = G::from_u64(149); + let __v_28: G = G::from_u64(6); + let __v_29: G = G::from_u64(232); + let __v_30: G = G::from_u64(76); + let __v_31: G = G::from_u64(16); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_157] = [__v_32]; + if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_158: usize = 0; +const IN_158: usize = 0; +const OUT_158: usize = 1; +fn aiur_fn_158( + inp: [G; IN_158], + 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 = G::from_u64(225); let __v_1: G = G::from_u64(238); @@ -16658,21 +17246,21 @@ fn aiur_fn_146( let __v_30: G = G::from_u64(147); let __v_31: G = G::from_u64(229); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_146] = [__v_32]; - if let Some(result) = record.function_queries[146].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_158] = [__v_32]; + if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_147: usize = 0; -const IN_147: usize = 0; -const OUT_147: usize = 1; -fn aiur_fn_147( - inp: [G; IN_147], +const INPUT_SIZE_159: usize = 0; +const IN_159: usize = 0; +const OUT_159: usize = 1; +fn aiur_fn_159( + inp: [G; IN_159], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_147], ExecError> { +) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(191); let __v_1: G = G::from_u64(5); @@ -16707,21 +17295,21 @@ fn aiur_fn_147( let __v_30: G = G::from_u64(125); let __v_31: G = G::from_u64(87); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_147] = [__v_32]; - if let Some(result) = record.function_queries[147].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_159] = [__v_32]; + if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_148: usize = 0; -const IN_148: usize = 0; -const OUT_148: usize = 1; -fn aiur_fn_148( - inp: [G; IN_148], +const INPUT_SIZE_160: usize = 0; +const IN_160: usize = 0; +const OUT_160: usize = 1; +fn aiur_fn_160( + inp: [G; IN_160], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_148], ExecError> { +) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(194); let __v_1: G = G::from_u64(254); @@ -16756,21 +17344,21 @@ fn aiur_fn_148( let __v_30: G = G::from_u64(75); let __v_31: G = G::from_u64(7); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_148] = [__v_32]; - if let Some(result) = record.function_queries[148].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_160] = [__v_32]; + if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_149: usize = 0; -const IN_149: usize = 0; -const OUT_149: usize = 1; -fn aiur_fn_149( - inp: [G; IN_149], +const INPUT_SIZE_161: usize = 0; +const IN_161: usize = 0; +const OUT_161: usize = 1; +fn aiur_fn_161( + inp: [G; IN_161], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_149], ExecError> { +) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(10); let __v_1: G = G::from_u64(236); @@ -16805,21 +17393,21 @@ fn aiur_fn_149( let __v_30: G = G::from_u64(84); let __v_31: G = G::from_u64(128); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_149] = [__v_32]; - if let Some(result) = record.function_queries[149].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_161] = [__v_32]; + if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_150: usize = 0; -const IN_150: usize = 0; -const OUT_150: usize = 1; -fn aiur_fn_150( - inp: [G; IN_150], +const INPUT_SIZE_162: usize = 0; +const IN_162: usize = 0; +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_150], ExecError> { +) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(89); let __v_1: G = G::from_u64(228); @@ -16854,21 +17442,21 @@ fn aiur_fn_150( let __v_30: G = G::from_u64(206); let __v_31: G = G::from_u64(66); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_150] = [__v_32]; - if let Some(result) = record.function_queries[150].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_162] = [__v_32]; + if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_151: usize = 0; -const IN_151: usize = 0; -const OUT_151: usize = 1; -fn aiur_fn_151( - inp: [G; IN_151], +const INPUT_SIZE_163: usize = 0; +const IN_163: usize = 0; +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_151], ExecError> { +) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(44); let __v_1: G = G::from_u64(157); @@ -16903,21 +17491,21 @@ fn aiur_fn_151( let __v_30: G = G::from_u64(171); let __v_31: G = G::from_u64(207); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_151] = [__v_32]; - if let Some(result) = record.function_queries[151].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_163] = [__v_32]; + if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_152: usize = 0; -const IN_152: usize = 0; -const OUT_152: usize = 1; -fn aiur_fn_152( - inp: [G; IN_152], +const INPUT_SIZE_164: usize = 0; +const IN_164: usize = 0; +const OUT_164: usize = 1; +fn aiur_fn_164( + inp: [G; IN_164], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_152], ExecError> { +) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(47); let __v_1: G = G::from_u64(18); @@ -16952,21 +17540,21 @@ fn aiur_fn_152( let __v_30: G = G::from_u64(113); let __v_31: G = G::from_u64(49); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_152] = [__v_32]; - if let Some(result) = record.function_queries[152].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_164] = [__v_32]; + if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_153: usize = 0; -const IN_153: usize = 0; -const OUT_153: usize = 1; -fn aiur_fn_153( - inp: [G; IN_153], +const INPUT_SIZE_165: usize = 0; +const IN_165: usize = 0; +const OUT_165: usize = 1; +fn aiur_fn_165( + inp: [G; IN_165], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_153], ExecError> { +) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(131); let __v_1: G = G::from_u64(60); @@ -17001,21 +17589,21 @@ fn aiur_fn_153( let __v_30: G = G::from_u64(14); let __v_31: G = G::from_u64(52); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_153] = [__v_32]; - if let Some(result) = record.function_queries[153].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_165] = [__v_32]; + if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_154: usize = 0; -const IN_154: usize = 0; -const OUT_154: usize = 1; -fn aiur_fn_154( - inp: [G; IN_154], +const INPUT_SIZE_166: usize = 0; +const IN_166: usize = 0; +const OUT_166: usize = 1; +fn aiur_fn_166( + inp: [G; IN_166], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_154], ExecError> { +) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(114); let __v_1: G = G::from_u64(50); @@ -17050,21 +17638,21 @@ fn aiur_fn_154( let __v_30: G = G::from_u64(171); let __v_31: G = G::from_u64(154); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_154] = [__v_32]; - if let Some(result) = record.function_queries[154].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_166] = [__v_32]; + if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_155: usize = 0; -const IN_155: usize = 0; -const OUT_155: usize = 1; -fn aiur_fn_155( - inp: [G; IN_155], +const INPUT_SIZE_167: usize = 0; +const IN_167: usize = 0; +const OUT_167: usize = 1; +fn aiur_fn_167( + inp: [G; IN_167], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_155], ExecError> { +) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(195); let __v_1: G = G::from_u64(176); @@ -17099,21 +17687,21 @@ fn aiur_fn_155( let __v_30: G = G::from_u64(4); let __v_31: G = G::from_u64(240); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_155] = [__v_32]; - if let Some(result) = record.function_queries[155].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_167] = [__v_32]; + if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_156: usize = 0; -const IN_156: usize = 0; -const OUT_156: usize = 1; -fn aiur_fn_156( - inp: [G; IN_156], +const INPUT_SIZE_168: usize = 0; +const IN_168: usize = 0; +const OUT_168: usize = 1; +fn aiur_fn_168( + inp: [G; IN_168], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_156], ExecError> { +) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(110); let __v_1: G = G::from_u64(112); @@ -17148,21 +17736,21 @@ fn aiur_fn_156( let __v_30: G = G::from_u64(9); let __v_31: G = G::from_u64(120); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_156] = [__v_32]; - if let Some(result) = record.function_queries[156].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_168] = [__v_32]; + if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_157: usize = 0; -const IN_157: usize = 0; -const OUT_157: usize = 1; -fn aiur_fn_157( - inp: [G; IN_157], +const INPUT_SIZE_169: usize = 0; +const IN_169: usize = 0; +const OUT_169: usize = 1; +fn aiur_fn_169( + inp: [G; IN_169], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_157], ExecError> { +) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(216); let __v_1: G = G::from_u64(221); @@ -17197,21 +17785,21 @@ fn aiur_fn_157( let __v_30: G = G::from_u64(249); let __v_31: G = G::from_u64(243); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_157] = [__v_32]; - if let Some(result) = record.function_queries[157].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_169] = [__v_32]; + if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_158: usize = 0; -const IN_158: usize = 0; -const OUT_158: usize = 1; -fn aiur_fn_158( - inp: [G; IN_158], +const INPUT_SIZE_170: usize = 0; +const IN_170: usize = 0; +const OUT_170: usize = 1; +fn aiur_fn_170( + inp: [G; IN_170], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_158], ExecError> { +) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(202); let __v_1: G = G::from_u64(48); @@ -17246,21 +17834,21 @@ fn aiur_fn_158( let __v_30: G = G::from_u64(32); let __v_31: G = G::from_u64(112); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_158] = [__v_32]; - if let Some(result) = record.function_queries[158].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_170] = [__v_32]; + if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_159: usize = 0; -const IN_159: usize = 0; -const OUT_159: usize = 1; -fn aiur_fn_159( - inp: [G; IN_159], +const INPUT_SIZE_171: usize = 0; +const IN_171: usize = 0; +const OUT_171: usize = 1; +fn aiur_fn_171( + inp: [G; IN_171], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_159], ExecError> { +) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(202); let __v_1: G = G::from_u64(75); @@ -17295,21 +17883,21 @@ fn aiur_fn_159( let __v_30: G = G::from_u64(28); let __v_31: G = G::from_u64(188); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_159] = [__v_32]; - if let Some(result) = record.function_queries[159].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_171] = [__v_32]; + if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_160: usize = 0; -const IN_160: usize = 0; -const OUT_160: usize = 1; -fn aiur_fn_160( - inp: [G; IN_160], +const INPUT_SIZE_172: usize = 0; +const IN_172: usize = 0; +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_160], ExecError> { +) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(162); let __v_1: G = G::from_u64(154); @@ -17344,21 +17932,21 @@ fn aiur_fn_160( let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(98); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_160] = [__v_32]; - if let Some(result) = record.function_queries[160].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_172] = [__v_32]; + if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_161: usize = 0; -const IN_161: usize = 0; -const OUT_161: usize = 1; -fn aiur_fn_161( - inp: [G; IN_161], +const INPUT_SIZE_173: usize = 0; +const IN_173: usize = 0; +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_161], ExecError> { +) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(221); let __v_1: G = G::from_u64(161); @@ -17393,21 +17981,21 @@ fn aiur_fn_161( let __v_30: G = G::from_u64(198); let __v_31: G = G::from_u64(62); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_161] = [__v_32]; - if let Some(result) = record.function_queries[161].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_173] = [__v_32]; + if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_162: usize = 0; -const IN_162: usize = 0; -const OUT_162: usize = 1; -fn aiur_fn_162( - inp: [G; IN_162], +const INPUT_SIZE_174: usize = 0; +const IN_174: usize = 0; +const OUT_174: usize = 1; +fn aiur_fn_174( + inp: [G; IN_174], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_162], ExecError> { +) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(169); let __v_1: G = G::from_u64(22); @@ -17442,21 +18030,21 @@ fn aiur_fn_162( let __v_30: G = G::from_u64(250); let __v_31: G = G::from_u64(236); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_162] = [__v_32]; - if let Some(result) = record.function_queries[162].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_174] = [__v_32]; + if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_163: usize = 0; -const IN_163: usize = 0; -const OUT_163: usize = 1; -fn aiur_fn_163( - inp: [G; IN_163], +const INPUT_SIZE_175: usize = 0; +const IN_175: usize = 0; +const OUT_175: usize = 1; +fn aiur_fn_175( + inp: [G; IN_175], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_163], ExecError> { +) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(123); let __v_1: G = G::from_u64(216); @@ -17491,21 +18079,21 @@ fn aiur_fn_163( let __v_30: G = G::from_u64(64); let __v_31: G = G::from_u64(18); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_163] = [__v_32]; - if let Some(result) = record.function_queries[163].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_175] = [__v_32]; + if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_164: usize = 0; -const IN_164: usize = 0; -const OUT_164: usize = 1; -fn aiur_fn_164( - inp: [G; IN_164], +const INPUT_SIZE_176: usize = 0; +const IN_176: usize = 0; +const OUT_176: usize = 1; +fn aiur_fn_176( + inp: [G; IN_176], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_164], ExecError> { +) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(28); let __v_1: G = G::from_u64(23); @@ -17540,21 +18128,21 @@ fn aiur_fn_164( let __v_30: G = G::from_u64(250); let __v_31: G = G::from_u64(120); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_164] = [__v_32]; - if let Some(result) = record.function_queries[164].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_176] = [__v_32]; + if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_165: usize = 0; -const IN_165: usize = 0; -const OUT_165: usize = 1; -fn aiur_fn_165( - inp: [G; IN_165], +const INPUT_SIZE_177: usize = 0; +const IN_177: usize = 0; +const OUT_177: usize = 1; +fn aiur_fn_177( + inp: [G; IN_177], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_165], ExecError> { +) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(22); let __v_1: G = G::from_u64(133); @@ -17589,21 +18177,21 @@ fn aiur_fn_165( let __v_30: G = G::from_u64(229); let __v_31: G = G::from_u64(96); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_165] = [__v_32]; - if let Some(result) = record.function_queries[165].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_177] = [__v_32]; + if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_166: usize = 0; -const IN_166: usize = 0; -const OUT_166: usize = 1; -fn aiur_fn_166( - inp: [G; IN_166], +const INPUT_SIZE_178: usize = 0; +const IN_178: usize = 0; +const OUT_178: usize = 1; +fn aiur_fn_178( + inp: [G; IN_178], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_166], ExecError> { +) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(12); let __v_1: G = G::from_u64(112); @@ -17638,21 +18226,21 @@ fn aiur_fn_166( let __v_30: G = G::from_u64(108); let __v_31: G = G::from_u64(113); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_166] = [__v_32]; - if let Some(result) = record.function_queries[166].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_178] = [__v_32]; + if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_167: usize = 0; -const IN_167: usize = 0; -const OUT_167: usize = 1; -fn aiur_fn_167( - inp: [G; IN_167], +const INPUT_SIZE_179: usize = 0; +const IN_179: usize = 0; +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_167], ExecError> { +) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(102); let __v_1: G = G::from_u64(242); @@ -17687,21 +18275,21 @@ fn aiur_fn_167( let __v_30: G = G::from_u64(189); let __v_31: G = G::from_u64(213); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_167] = [__v_32]; - if let Some(result) = record.function_queries[167].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_179] = [__v_32]; + if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_168: usize = 0; -const IN_168: usize = 0; -const OUT_168: usize = 1; -fn aiur_fn_168( - inp: [G; IN_168], +const INPUT_SIZE_180: usize = 0; +const IN_180: usize = 0; +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_168], ExecError> { +) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(163); let __v_1: G = G::from_u64(67); @@ -17736,21 +18324,21 @@ fn aiur_fn_168( let __v_30: G = G::from_u64(60); let __v_31: G = G::from_u64(74); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_168] = [__v_32]; - if let Some(result) = record.function_queries[168].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_180] = [__v_32]; + if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_169: usize = 0; -const IN_169: usize = 0; -const OUT_169: usize = 1; -fn aiur_fn_169( - inp: [G; IN_169], +const INPUT_SIZE_181: usize = 0; +const IN_181: usize = 0; +const OUT_181: usize = 1; +fn aiur_fn_181( + inp: [G; IN_181], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_169], ExecError> { +) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(45); let __v_1: G = G::from_u64(252); @@ -17785,21 +18373,21 @@ fn aiur_fn_169( let __v_30: G = G::from_u64(105); let __v_31: G = G::from_u64(91); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_169] = [__v_32]; - if let Some(result) = record.function_queries[169].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_181] = [__v_32]; + if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_170: usize = 0; -const IN_170: usize = 0; -const OUT_170: usize = 1; -fn aiur_fn_170( - inp: [G; IN_170], +const INPUT_SIZE_182: usize = 0; +const IN_182: usize = 0; +const OUT_182: usize = 1; +fn aiur_fn_182( + inp: [G; IN_182], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_170], ExecError> { +) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(146); let __v_1: G = G::from_u64(50); @@ -17834,98 +18422,98 @@ fn aiur_fn_170( let __v_30: G = G::from_u64(15); let __v_31: G = G::from_u64(235); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_170] = [__v_32]; - if let Some(result) = record.function_queries[170].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_182] = [__v_32]; + if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_171: usize = 1; -const IN_171: usize = 1; -const OUT_171: usize = 1; -fn aiur_fn_171( - inp: [G; IN_171], +const INPUT_SIZE_183: usize = 1; +const IN_183: usize = 1; +const OUT_183: usize = 1; +fn aiur_fn_183( + inp: [G; IN_183], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_171], ExecError> { +) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_171] = [__v_3]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_3]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_171] = [__v_5]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_5]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_171] = [__v_7]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_7]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_171] = [__v_9]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_9]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_171] = [__v_11]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_11]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_171] = [__v_13]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_13]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_171] = [__v_13]; - if let Some(result) = record.function_queries[171].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_183] = [__v_13]; + if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -17942,15 +18530,15 @@ fn aiur_fn_171( }) } -const INPUT_SIZE_172: usize = 0; -const IN_172: usize = 0; -const OUT_172: usize = 1; -fn aiur_fn_172( - inp: [G; IN_172], +const INPUT_SIZE_184: usize = 0; +const IN_184: usize = 0; +const OUT_184: usize = 1; +fn aiur_fn_184( + inp: [G; IN_184], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_172], ExecError> { +) -> Result<[G; OUT_184], 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); @@ -17969,21 +18557,21 @@ fn aiur_fn_172( 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_172] = [__v_16]; - if let Some(result) = record.function_queries[172].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_184] = [__v_16]; + if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_173: usize = 0; -const IN_173: usize = 0; -const OUT_173: usize = 1; -fn aiur_fn_173( - inp: [G; IN_173], +const INPUT_SIZE_185: usize = 0; +const IN_185: usize = 0; +const OUT_185: usize = 1; +fn aiur_fn_185( + inp: [G; IN_185], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_173], ExecError> { +) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(0); let __v_1: G = G::from_u64(1); @@ -18002,86 +18590,86 @@ fn aiur_fn_173( 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_173] = [__v_16]; - if let Some(result) = record.function_queries[173].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_185] = [__v_16]; + if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_174: usize = 3; -const IN_174: usize = 3; -const OUT_174: usize = 2; -fn aiur_fn_174( - inp: [G; IN_174], +const INPUT_SIZE_186: usize = 3; +const IN_186: usize = 3; +const OUT_186: usize = 2; +fn aiur_fn_186( + inp: [G; IN_186], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_174], ExecError> { +) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_174] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_174] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_175(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_174] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_174] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_176(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -18093,12 +18681,12 @@ fn aiur_fn_174( 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_174] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __v_18: G = { let __a_val = __v_16.as_canonical_u64(); let __b_val = __v_17.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -18109,31 +18697,31 @@ fn aiur_fn_174( 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_174] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_177(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __ret: [G; OUT_174] = [__v_22, __v_23]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_22, __v_23]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_178(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_178] = unsafe { *(result.output.as_ptr() as *const [G; OUT_178]) }; __ret } } else { aiur_fn_178(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __ret: [G; OUT_174] = [__v_22, __v_23]; - if let Some(result) = record.function_queries[174].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_186] = [__v_22, __v_23]; + if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18152,18 +18740,18 @@ fn aiur_fn_174( }) } -const INPUT_SIZE_175: usize = 1; -const IN_175: usize = 1; -const OUT_175: usize = 2; -fn aiur_fn_175( - inp: [G; IN_175], +const INPUT_SIZE_187: usize = 1; +const IN_187: usize = 1; +const OUT_187: usize = 2; +fn aiur_fn_187( + inp: [G; IN_187], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_175], ExecError> { +) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -18174,13 +18762,13 @@ fn aiur_fn_175( 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_175] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -18192,17 +18780,17 @@ fn aiur_fn_175( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_175] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18211,8 +18799,8 @@ fn aiur_fn_175( 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_175] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18223,8 +18811,8 @@ fn aiur_fn_175( 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_175] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[175].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_187] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18233,18 +18821,18 @@ fn aiur_fn_175( }) } -const INPUT_SIZE_176: usize = 1; -const IN_176: usize = 1; -const OUT_176: usize = 2; -fn aiur_fn_176( - inp: [G; IN_176], +const INPUT_SIZE_188: usize = 1; +const IN_188: usize = 1; +const OUT_188: usize = 2; +fn aiur_fn_188( + inp: [G; IN_188], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_176], ExecError> { +) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -18255,13 +18843,13 @@ fn aiur_fn_176( 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_176] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -18273,31 +18861,31 @@ fn aiur_fn_176( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_176] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_176] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18306,8 +18894,8 @@ fn aiur_fn_176( 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_176] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18320,8 +18908,8 @@ fn aiur_fn_176( 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_176] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[176].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_188] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18330,15 +18918,15 @@ fn aiur_fn_176( }) } -const INPUT_SIZE_177: usize = 1; -const IN_177: usize = 1; -const OUT_177: usize = 2; -fn aiur_fn_177( - inp: [G; IN_177], +const INPUT_SIZE_189: usize = 1; +const IN_189: usize = 1; +const OUT_189: usize = 2; +fn aiur_fn_189( + inp: [G; IN_189], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_177], ExecError> { +) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -18348,11 +18936,11 @@ fn aiur_fn_177( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -18364,14 +18952,14 @@ fn aiur_fn_177( 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_177] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_189] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_177] = [__v_10, __v_0]; - if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_189] = [__v_10, __v_0]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18382,23 +18970,23 @@ fn aiur_fn_177( 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_177] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[177].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_189] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_178: usize = 1; -const IN_178: usize = 1; -const OUT_178: usize = 2; -fn aiur_fn_178( - inp: [G; IN_178], +const INPUT_SIZE_190: usize = 1; +const IN_190: usize = 1; +const OUT_190: usize = 2; +fn aiur_fn_190( + inp: [G; IN_190], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_178], ExecError> { +) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -18411,8 +18999,8 @@ fn aiur_fn_178( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_178] = [__v_5, __v_0]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_5, __v_0]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18421,8 +19009,8 @@ fn aiur_fn_178( 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_178] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18433,23 +19021,23 @@ fn aiur_fn_178( 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_178] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[178].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_190] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_179: usize = 0; -const IN_179: usize = 0; -const OUT_179: usize = 1; -fn aiur_fn_179( - inp: [G; IN_179], +const INPUT_SIZE_191: usize = 0; +const IN_191: usize = 0; +const OUT_191: usize = 1; +fn aiur_fn_191( + inp: [G; IN_191], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_179], ExecError> { +) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(227); let __v_1: G = G::from_u64(42); @@ -18484,21 +19072,21 @@ fn aiur_fn_179( let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(116); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_179] = [__v_32]; - if let Some(result) = record.function_queries[179].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_191] = [__v_32]; + if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_180: usize = 0; -const IN_180: usize = 0; -const OUT_180: usize = 1; -fn aiur_fn_180( - inp: [G; IN_180], +const INPUT_SIZE_192: usize = 0; +const IN_192: usize = 0; +const OUT_192: usize = 1; +fn aiur_fn_192( + inp: [G; IN_192], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_180], ExecError> { +) -> Result<[G; OUT_192], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(59); let __v_1: G = G::from_u64(51); @@ -18533,21 +19121,21 @@ fn aiur_fn_180( let __v_30: G = G::from_u64(191); let __v_31: G = G::from_u64(110); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_180] = [__v_32]; - if let Some(result) = record.function_queries[180].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_192] = [__v_32]; + if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_181: usize = 0; -const IN_181: usize = 0; -const OUT_181: usize = 1; -fn aiur_fn_181( - inp: [G; IN_181], +const INPUT_SIZE_193: usize = 0; +const IN_193: usize = 0; +const OUT_193: usize = 1; +fn aiur_fn_193( + inp: [G; IN_193], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_181], ExecError> { +) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(103); let __v_1: G = G::from_u64(244); @@ -18582,21 +19170,21 @@ fn aiur_fn_181( let __v_30: G = G::from_u64(43); let __v_31: G = G::from_u64(164); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_181] = [__v_32]; - if let Some(result) = record.function_queries[181].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_193] = [__v_32]; + if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_182: usize = 0; -const IN_182: usize = 0; -const OUT_182: usize = 1; -fn aiur_fn_182( - inp: [G; IN_182], +const INPUT_SIZE_194: usize = 0; +const IN_194: usize = 0; +const OUT_194: usize = 1; +fn aiur_fn_194( + inp: [G; IN_194], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_182], ExecError> { +) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(79); let __v_1: G = G::from_u64(157); @@ -18631,21 +19219,21 @@ fn aiur_fn_182( let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(204); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_182] = [__v_32]; - if let Some(result) = record.function_queries[182].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_194] = [__v_32]; + if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_183: usize = 0; -const IN_183: usize = 0; -const OUT_183: usize = 1; -fn aiur_fn_183( - inp: [G; IN_183], +const INPUT_SIZE_195: usize = 0; +const IN_195: usize = 0; +const OUT_195: usize = 1; +fn aiur_fn_195( + inp: [G; IN_195], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_183], ExecError> { +) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(197); let __v_1: G = G::from_u64(247); @@ -18680,21 +19268,21 @@ fn aiur_fn_183( let __v_30: G = G::from_u64(55); let __v_31: G = G::from_u64(35); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_183] = [__v_32]; - if let Some(result) = record.function_queries[183].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_195] = [__v_32]; + if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_184: usize = 0; -const IN_184: usize = 0; -const OUT_184: usize = 1; -fn aiur_fn_184( - inp: [G; IN_184], +const INPUT_SIZE_196: usize = 0; +const IN_196: usize = 0; +const OUT_196: usize = 1; +fn aiur_fn_196( + inp: [G; IN_196], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_184], ExecError> { +) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(202); let __v_1: G = G::from_u64(202); @@ -18729,62 +19317,62 @@ fn aiur_fn_184( let __v_30: G = G::from_u64(51); let __v_31: G = G::from_u64(18); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_184] = [__v_32]; - if let Some(result) = record.function_queries[184].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_196] = [__v_32]; + if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_185: usize = 1; -const IN_185: usize = 1; -const OUT_185: usize = 1; -fn aiur_fn_185( - inp: [G; IN_185], +const INPUT_SIZE_197: usize = 1; +const IN_197: usize = 1; +const OUT_197: usize = 1; +fn aiur_fn_197( + inp: [G; IN_197], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_185], ExecError> { +) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_185] = [__v_3]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_3]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_185] = [__v_5]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_5]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_185] = [__v_7]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_7]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_185] = [__v_7]; - if let Some(result) = record.function_queries[185].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_197] = [__v_7]; + if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -18795,61 +19383,61 @@ fn aiur_fn_185( }) } -const INPUT_SIZE_186: usize = 1; -const IN_186: usize = 1; -const OUT_186: usize = 1; -fn aiur_fn_186( - inp: [G; IN_186], +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_186], ExecError> { +) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_7]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_7]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_1, __v_2, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_7]; - if let Some(result) = record.function_queries[186].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_198] = [__v_7]; + if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_187: usize = 2; -const IN_187: usize = 2; -const OUT_187: usize = 2; -fn aiur_fn_187( - inp: [G; IN_187], +const INPUT_SIZE_199: usize = 2; +const IN_199: usize = 2; +const OUT_199: usize = 2; +fn aiur_fn_199( + inp: [G; IN_199], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_187], ExecError> { +) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_190(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -18859,12 +19447,12 @@ fn aiur_fn_187( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_187] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -18873,12 +19461,12 @@ fn aiur_fn_187( 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_187] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { @@ -18887,8 +19475,8 @@ fn aiur_fn_187( 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_187] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -18912,8 +19500,8 @@ fn aiur_fn_187( let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_187] = [__v_23, __v_25]; - if let Some(result) = record.function_queries[187].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_199] = [__v_23, __v_25]; + if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -18933,18 +19521,18 @@ fn aiur_fn_187( }) } -const INPUT_SIZE_188: usize = 1; -const IN_188: usize = 1; -const OUT_188: usize = 2; -fn aiur_fn_188( - inp: [G; IN_188], +const INPUT_SIZE_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_188], ExecError> { +) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(3); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -18955,21 +19543,21 @@ fn aiur_fn_188( 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_188] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { @@ -18979,12 +19567,12 @@ fn aiur_fn_188( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { 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_188] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -18994,8 +19582,8 @@ fn aiur_fn_188( 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_188] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -19004,10 +19592,10 @@ fn aiur_fn_188( let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 - __v_15); let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_188] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[188].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_200] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19024,18 +19612,18 @@ fn aiur_fn_188( }) } -const INPUT_SIZE_189: usize = 1; -const IN_189: usize = 1; -const OUT_189: usize = 2; -fn aiur_fn_189( - inp: [G; IN_189], +const INPUT_SIZE_201: usize = 1; +const IN_201: usize = 1; +const OUT_201: usize = 2; +fn aiur_fn_201( + inp: [G; IN_201], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_189], ExecError> { +) -> Result<[G; OUT_201], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(2); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19046,13 +19634,13 @@ fn aiur_fn_189( 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_189] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -19064,7 +19652,7 @@ fn aiur_fn_189( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_184(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; @@ -19075,12 +19663,12 @@ fn aiur_fn_189( 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_189] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19091,13 +19679,13 @@ fn aiur_fn_189( 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_189] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; @@ -19109,7 +19697,7 @@ fn aiur_fn_189( let __v_24: G = __loaded[3]; match __v_21.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_181(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; @@ -19120,12 +19708,12 @@ fn aiur_fn_189( 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_189] = [__v_27, __v_31]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_27, __v_31]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = { let __a_val = __v_27.as_canonical_u64(); let __b_val = __v_28.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19136,19 +19724,19 @@ fn aiur_fn_189( let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); let __v_34: G = { let __values: [G; 4] = [__v_31, __v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_189] = [__v_30, __v_34]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_30, __v_34]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_30: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_20, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(3); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); @@ -19159,11 +19747,11 @@ fn aiur_fn_189( let __v_42: G = { let __values: [G; 3] = [__v_38, __v_35, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_43: G = { let __values: [G; 3] = [__v_37, __v_33, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_44: G = { let __values: [G; 3] = [__v_36, __v_31, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_189] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_45, __v_46]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19176,8 +19764,8 @@ fn aiur_fn_189( 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_189] = [__v_25, __v_29]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_25, __v_29]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19192,8 +19780,8 @@ fn aiur_fn_189( 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_189] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[189].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_201] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19202,15 +19790,15 @@ fn aiur_fn_189( }) } -const INPUT_SIZE_190: usize = 1; -const IN_190: usize = 1; -const OUT_190: usize = 3; -fn aiur_fn_190( - inp: [G; IN_190], +const INPUT_SIZE_202: usize = 1; +const IN_202: usize = 1; +const OUT_202: usize = 3; +fn aiur_fn_202( + inp: [G; IN_202], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_190], ExecError> { +) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; @@ -19223,13 +19811,13 @@ fn aiur_fn_190( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_180(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(2); let __v_11: G = (__v_9 - __v_10); @@ -19237,13 +19825,13 @@ fn aiur_fn_190( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_190] = [__v_12, __v_14, __v_16]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_12, __v_14, __v_16]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19256,8 +19844,8 @@ fn aiur_fn_190( 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_190] = [__v_12, __v_16, __v_20]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_12, __v_16, __v_20]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19272,8 +19860,8 @@ fn aiur_fn_190( 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_190] = [__v_9, __v_13, __v_17]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_9, __v_13, __v_17]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19288,34 +19876,34 @@ fn aiur_fn_190( 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_190] = [__v_7, __v_11, __v_15]; - if let Some(result) = record.function_queries[190].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_202] = [__v_7, __v_11, __v_15]; + if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_191: usize = 3; -const IN_191: usize = 3; -const OUT_191: usize = 2; -fn aiur_fn_191( - inp: [G; IN_191], +const INPUT_SIZE_203: usize = 3; +const IN_203: usize = 3; +const OUT_203: usize = 2; +fn aiur_fn_203( + inp: [G; IN_203], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_191], ExecError> { +) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_179(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(2); let __v_7: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -19326,20 +19914,20 @@ fn aiur_fn_191( 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_191] = [__v_8, __v_12]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_8, __v_12]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_187(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { @@ -19349,16 +19937,16 @@ fn aiur_fn_191( 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_191] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_191] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19369,33 +19957,33 @@ fn aiur_fn_191( } }, _ => { - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_182(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_192(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_188(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_191] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_189(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_191] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19404,8 +19992,8 @@ fn aiur_fn_191( 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_191] = [__v_9, __v_13]; - if let Some(result) = record.function_queries[191].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_203] = [__v_9, __v_13]; + if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -19416,19 +20004,19 @@ fn aiur_fn_191( }) } -const INPUT_SIZE_192: usize = 2; -const IN_192: usize = 2; -const OUT_192: usize = 1; -fn aiur_fn_192( - inp: [G; IN_192], +const INPUT_SIZE_204: usize = 2; +const IN_204: usize = 2; +const OUT_204: usize = 1; +fn aiur_fn_204( + inp: [G; IN_204], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_192], ExecError> { +) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -19436,8 +20024,8 @@ fn aiur_fn_192( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_192] = [__v_2]; - if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = [__v_2]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -19447,8 +20035,8 @@ fn aiur_fn_192( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_192] = [__v_2]; - if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = [__v_2]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -19458,14 +20046,14 @@ fn aiur_fn_192( let __v_11: G = __loaded[2]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_192] = [__v_2]; - if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = [__v_2]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_193(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); @@ -19473,8 +20061,8 @@ fn aiur_fn_192( let __v_17: G = { let __values: [G; 3] = [__v_16, __v_13, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = { let __values: [G; 3] = [__v_15, __v_12, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = { let __values: [G; 3] = [__v_14, __v_4, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_192] = [__v_19]; - if let Some(result) = record.function_queries[192].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_204] = [__v_19]; + if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -19494,40 +20082,40 @@ fn aiur_fn_192( }) } -const INPUT_SIZE_193: usize = 2; -const IN_193: usize = 2; -const OUT_193: usize = 1; -fn aiur_fn_193( - inp: [G; IN_193], +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_193], ExecError> { +) -> Result<[G; OUT_205], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_193] = [__v_5]; - if let Some(result) = record.function_queries[193].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_205] = [__v_5]; + if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_194: usize = 0; -const IN_194: usize = 0; -const OUT_194: usize = 1; -fn aiur_fn_194( - inp: [G; IN_194], +const INPUT_SIZE_206: usize = 0; +const IN_206: usize = 0; +const OUT_206: usize = 1; +fn aiur_fn_206( + inp: [G; IN_206], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_194], ExecError> { +) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(81); let __v_1: G = G::from_u64(134); @@ -19562,21 +20150,21 @@ fn aiur_fn_194( let __v_30: G = G::from_u64(90); let __v_31: G = G::from_u64(110); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_194] = [__v_32]; - if let Some(result) = record.function_queries[194].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_206] = [__v_32]; + if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_195: usize = 0; -const IN_195: usize = 0; -const OUT_195: usize = 1; -fn aiur_fn_195( - inp: [G; IN_195], +const INPUT_SIZE_207: usize = 0; +const IN_207: usize = 0; +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_195], ExecError> { +) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(255); let __v_1: G = G::from_u64(69); @@ -19611,21 +20199,21 @@ fn aiur_fn_195( let __v_30: G = G::from_u64(3); let __v_31: G = G::from_u64(158); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_195] = [__v_32]; - if let Some(result) = record.function_queries[195].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_207] = [__v_32]; + if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_196: usize = 0; -const IN_196: usize = 0; -const OUT_196: usize = 1; -fn aiur_fn_196( - inp: [G; IN_196], +const INPUT_SIZE_208: usize = 0; +const IN_208: usize = 0; +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_196], ExecError> { +) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(2); @@ -19660,21 +20248,21 @@ fn aiur_fn_196( let __v_30: G = G::from_u64(40); let __v_31: G = G::from_u64(217); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_196] = [__v_32]; - if let Some(result) = record.function_queries[196].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_208] = [__v_32]; + if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; 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], +const INPUT_SIZE_209: usize = 0; +const IN_209: usize = 0; +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_197], ExecError> { +) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(9); let __v_1: G = G::from_u64(238); @@ -19709,21 +20297,21 @@ fn aiur_fn_197( let __v_30: G = G::from_u64(141); let __v_31: G = G::from_u64(52); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_32]; - if let Some(result) = record.function_queries[197].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_209] = [__v_32]; + if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_198: usize = 0; -const IN_198: usize = 0; -const OUT_198: usize = 1; -fn aiur_fn_198( - inp: [G; IN_198], +const INPUT_SIZE_210: usize = 0; +const IN_210: usize = 0; +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_198], ExecError> { +) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(37); let __v_1: G = G::from_u64(138); @@ -19758,21 +20346,21 @@ fn aiur_fn_198( let __v_30: G = G::from_u64(202); let __v_31: G = G::from_u64(62); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_198] = [__v_32]; - if let Some(result) = record.function_queries[198].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_210] = [__v_32]; + if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_199: usize = 0; -const IN_199: usize = 0; -const OUT_199: usize = 1; -fn aiur_fn_199( - inp: [G; IN_199], +const INPUT_SIZE_211: usize = 0; +const IN_211: usize = 0; +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_199], ExecError> { +) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(119); let __v_1: G = G::from_u64(213); @@ -19807,21 +20395,21 @@ fn aiur_fn_199( let __v_30: G = G::from_u64(2); let __v_31: G = G::from_u64(160); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_199] = [__v_32]; - if let Some(result) = record.function_queries[199].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_211] = [__v_32]; + if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_200: usize = 0; -const IN_200: usize = 0; -const OUT_200: usize = 1; -fn aiur_fn_200( - inp: [G; IN_200], +const INPUT_SIZE_212: usize = 0; +const IN_212: usize = 0; +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_200], ExecError> { +) -> Result<[G; OUT_212], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(32); let __v_1: G = G::from_u64(59); @@ -19856,21 +20444,21 @@ fn aiur_fn_200( let __v_30: G = G::from_u64(110); let __v_31: G = G::from_u64(238); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_200] = [__v_32]; - if let Some(result) = record.function_queries[200].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_212] = [__v_32]; + if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_201: usize = 0; -const IN_201: usize = 0; -const OUT_201: usize = 1; -fn aiur_fn_201( - inp: [G; IN_201], +const INPUT_SIZE_213: usize = 0; +const IN_213: usize = 0; +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_201], ExecError> { +) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(84); let __v_1: G = G::from_u64(139); @@ -19905,21 +20493,21 @@ fn aiur_fn_201( let __v_30: G = G::from_u64(29); let __v_31: G = G::from_u64(101); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_201] = [__v_32]; - if let Some(result) = record.function_queries[201].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_213] = [__v_32]; + if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_202: usize = 0; -const IN_202: usize = 0; -const OUT_202: usize = 1; -fn aiur_fn_202( - inp: [G; IN_202], +const INPUT_SIZE_214: usize = 0; +const IN_214: usize = 0; +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_202], ExecError> { +) -> Result<[G; OUT_214], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(239); let __v_1: G = G::from_u64(78); @@ -19954,21 +20542,21 @@ fn aiur_fn_202( let __v_30: G = G::from_u64(253); let __v_31: G = G::from_u64(201); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_202] = [__v_32]; - if let Some(result) = record.function_queries[202].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_214] = [__v_32]; + if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_203: usize = 0; -const IN_203: usize = 0; -const OUT_203: usize = 1; -fn aiur_fn_203( - inp: [G; IN_203], +const INPUT_SIZE_215: usize = 0; +const IN_215: usize = 0; +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_203], ExecError> { +) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(135); let __v_1: G = G::from_u64(9); @@ -20003,21 +20591,21 @@ fn aiur_fn_203( let __v_30: G = G::from_u64(12); let __v_31: G = G::from_u64(41); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_203] = [__v_32]; - if let Some(result) = record.function_queries[203].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_215] = [__v_32]; + if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_204: usize = 0; -const IN_204: usize = 0; -const OUT_204: usize = 1; -fn aiur_fn_204( - inp: [G; IN_204], +const INPUT_SIZE_216: usize = 0; +const IN_216: usize = 0; +const OUT_216: usize = 1; +fn aiur_fn_216( + inp: [G; IN_216], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_204], ExecError> { +) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(13); let __v_1: G = G::from_u64(35); @@ -20052,21 +20640,21 @@ fn aiur_fn_204( let __v_30: G = G::from_u64(226); let __v_31: G = G::from_u64(34); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_204] = [__v_32]; - if let Some(result) = record.function_queries[204].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_216] = [__v_32]; + if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_205: usize = 0; -const IN_205: usize = 0; -const OUT_205: usize = 1; -fn aiur_fn_205( - inp: [G; IN_205], +const INPUT_SIZE_217: usize = 0; +const IN_217: usize = 0; +const OUT_217: usize = 1; +fn aiur_fn_217( + inp: [G; IN_217], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_205], ExecError> { +) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(20); let __v_1: G = G::from_u64(207); @@ -20101,21 +20689,21 @@ fn aiur_fn_205( let __v_30: G = G::from_u64(229); let __v_31: G = G::from_u64(107); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_205] = [__v_32]; - if let Some(result) = record.function_queries[205].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_217] = [__v_32]; + if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_206: usize = 0; -const IN_206: usize = 0; -const OUT_206: usize = 1; -fn aiur_fn_206( - inp: [G; IN_206], +const INPUT_SIZE_218: usize = 0; +const IN_218: usize = 0; +const OUT_218: usize = 1; +fn aiur_fn_218( + inp: [G; IN_218], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_206], ExecError> { +) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(253); let __v_1: G = G::from_u64(83); @@ -20150,110 +20738,110 @@ fn aiur_fn_206( let __v_30: G = G::from_u64(101); let __v_31: G = G::from_u64(135); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_206] = [__v_32]; - if let Some(result) = record.function_queries[206].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_218] = [__v_32]; + if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_207: usize = 1; -const IN_207: usize = 1; -const OUT_207: usize = 1; -fn aiur_fn_207( - inp: [G; IN_207], +const INPUT_SIZE_219: usize = 1; +const IN_219: usize = 1; +const OUT_219: usize = 1; +fn aiur_fn_219( + inp: [G; IN_219], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_207], ExecError> { +) -> Result<[G; OUT_219], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_207] = [__v_3]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_3]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_207] = [__v_5]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_5]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_207] = [__v_7]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_7]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_207] = [__v_9]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_9]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_207] = [__v_11]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_11]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_207] = [__v_13]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_13]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_207] = [__v_15]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_15]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_207] = [__v_15]; - if let Some(result) = record.function_queries[207].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_219] = [__v_15]; + if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20272,22 +20860,22 @@ fn aiur_fn_207( }) } -const INPUT_SIZE_208: usize = 3; -const IN_208: usize = 3; -const OUT_208: usize = 2; -fn aiur_fn_208( - inp: [G; IN_208], +const INPUT_SIZE_220: usize = 3; +const IN_220: usize = 3; +const OUT_220: usize = 2; +fn aiur_fn_220( + inp: [G; IN_220], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_208], ExecError> { +) -> Result<[G; OUT_220], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -20296,9 +20884,9 @@ fn aiur_fn_208( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -20308,8 +20896,8 @@ fn aiur_fn_208( let __v_12: G = G::from_u64(1); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_208] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -20318,8 +20906,8 @@ fn aiur_fn_208( 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_208] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20333,14 +20921,14 @@ fn aiur_fn_208( 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_208] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_194(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -20355,13 +20943,13 @@ fn aiur_fn_208( 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_208] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -20372,9 +20960,9 @@ fn aiur_fn_208( 7u64 => { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; @@ -20383,8 +20971,8 @@ fn aiur_fn_208( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_20, __v_21, __v_18, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_208] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20393,8 +20981,8 @@ fn aiur_fn_208( 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_208] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20405,8 +20993,8 @@ fn aiur_fn_208( 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_208] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20414,63 +21002,63 @@ fn aiur_fn_208( } }, _ => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_201(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_208] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_202(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_208] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_208] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_205(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_208] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_195(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; @@ -20485,16 +21073,16 @@ fn aiur_fn_208( 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_208] = [__v_20, __v_24]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_20, __v_24]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -20514,15 +21102,15 @@ fn aiur_fn_208( 7u64 => { match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_26, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(7); let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_32, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_208] = [__v_33, __v_37]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_33, __v_37]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20531,8 +21119,8 @@ fn aiur_fn_208( 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_208] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_32, __v_36]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20543,8 +21131,8 @@ fn aiur_fn_208( 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_208] = [__v_32, __v_36]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_32, __v_36]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20555,8 +21143,8 @@ fn aiur_fn_208( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_208] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_28, __v_32]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20567,8 +21155,8 @@ fn aiur_fn_208( let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 4] = [__v_29, __v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_208] = [__v_28, __v_32]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_28, __v_32]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20581,8 +21169,8 @@ fn aiur_fn_208( 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_208] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[208].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_220] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20601,18 +21189,18 @@ fn aiur_fn_208( }) } -const INPUT_SIZE_209: usize = 1; -const IN_209: usize = 1; -const OUT_209: usize = 2; -fn aiur_fn_209( - inp: [G; IN_209], +const INPUT_SIZE_221: usize = 1; +const IN_221: usize = 1; +const OUT_221: usize = 2; +fn aiur_fn_221( + inp: [G; IN_221], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_209], ExecError> { +) -> Result<[G; OUT_221], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -20623,13 +21211,13 @@ fn aiur_fn_209( 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_209] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -20640,16 +21228,16 @@ fn aiur_fn_209( 7u64 => { match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(7); let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_16: G = G::from_u64(2); - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = G::from_u64(1); @@ -20660,8 +21248,8 @@ fn aiur_fn_209( let __v_24: G = G::from_u64(3); let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_24, __v_22, __v_15, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_209] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_23, __v_26]; + if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20670,8 +21258,8 @@ fn aiur_fn_209( 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_209] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20682,8 +21270,8 @@ fn aiur_fn_209( 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_209] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[209].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_221] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20692,18 +21280,18 @@ fn aiur_fn_209( }) } -const INPUT_SIZE_210: usize = 1; -const IN_210: usize = 1; -const OUT_210: usize = 2; -fn aiur_fn_210( - inp: [G; IN_210], +const INPUT_SIZE_222: usize = 1; +const IN_222: usize = 1; +const OUT_222: usize = 2; +fn aiur_fn_222( + inp: [G; IN_222], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_210], ExecError> { +) -> Result<[G; OUT_222], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = G::from_u64(1); let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -20714,13 +21302,13 @@ fn aiur_fn_210( 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_210] = [__v_4, __v_8]; - if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_4, __v_8]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -20739,15 +21327,15 @@ fn aiur_fn_210( 1u64 => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(2); - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_204(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(0); let __v_20: G = { let __values: [G; 4] = [__v_14, __v_15, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_210] = [__v_13, __v_20]; - if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_13, __v_20]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20756,8 +21344,8 @@ fn aiur_fn_210( 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_210] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20768,8 +21356,8 @@ fn aiur_fn_210( 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_210] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20780,8 +21368,8 @@ fn aiur_fn_210( 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_210] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[210].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_222] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -20790,15 +21378,15 @@ fn aiur_fn_210( }) } -const INPUT_SIZE_211: usize = 1; -const IN_211: usize = 1; -const OUT_211: usize = 0; -fn aiur_fn_211( - inp: [G; IN_211], +const INPUT_SIZE_223: usize = 1; +const IN_223: usize = 1; +const OUT_223: usize = 0; +fn aiur_fn_223( + inp: [G; IN_223], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_211], ExecError> { +) -> Result<[G; OUT_223], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -20807,17 +21395,17 @@ fn aiur_fn_211( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_211] = []; - if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_223] = []; + if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_211] = []; - if let Some(result) = record.function_queries[211].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_223] = []; + if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20827,35 +21415,35 @@ fn aiur_fn_211( }) } -const INPUT_SIZE_212: usize = 1; -const IN_212: usize = 1; -const OUT_212: usize = 1; -fn aiur_fn_212( - inp: [G; IN_212], +const INPUT_SIZE_224: usize = 1; +const IN_224: usize = 1; +const OUT_224: usize = 1; +fn aiur_fn_224( + inp: [G; IN_224], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_212], ExecError> { +) -> Result<[G; OUT_224], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(65); - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_212] = [__v_2]; - if let Some(result) = record.function_queries[212].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_224] = [__v_2]; + if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_213: usize = 2; -const IN_213: usize = 2; -const OUT_213: usize = 1; -fn aiur_fn_213( - inp: [G; IN_213], +const INPUT_SIZE_225: usize = 2; +const IN_225: usize = 2; +const OUT_225: usize = 1; +fn aiur_fn_225( + inp: [G; IN_225], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_213], ExecError> { +) -> Result<[G; OUT_225], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -20865,18 +21453,18 @@ fn aiur_fn_213( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_213] = [__v_1]; - if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_225] = [__v_1]; + if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_213(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_213] = [__v_7]; - if let Some(result) = record.function_queries[213].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_225] = [__v_7]; + if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20886,15 +21474,15 @@ fn aiur_fn_213( }) } -const INPUT_SIZE_214: usize = 1; -const IN_214: usize = 1; -const OUT_214: usize = 1; -fn aiur_fn_214( - inp: [G; IN_214], +const INPUT_SIZE_226: usize = 1; +const IN_226: usize = 1; +const OUT_226: usize = 1; +fn aiur_fn_226( + inp: [G; IN_226], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_214], ExecError> { +) -> Result<[G; OUT_226], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(128); @@ -20907,8 +21495,8 @@ fn aiur_fn_214( 1u64 => { let __v_5: G = G::from_u64(128); let __v_6: G = (__v_0 - __v_5); - let __ret: [G; OUT_214] = [__v_6]; - if let Some(result) = record.function_queries[214].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_226] = [__v_6]; + if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20923,15 +21511,15 @@ fn aiur_fn_214( }) } -const INPUT_SIZE_215: usize = 2; -const IN_215: usize = 2; -const OUT_215: usize = 2; -fn aiur_fn_215( - inp: [G; IN_215], +const INPUT_SIZE_227: usize = 2; +const IN_227: usize = 2; +const OUT_227: usize = 2; +fn aiur_fn_227( + inp: [G; IN_227], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_215], ExecError> { +) -> Result<[G; OUT_227], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -20939,8 +21527,8 @@ fn aiur_fn_215( 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_215] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20962,11 +21550,11 @@ fn aiur_fn_215( let __v_12: G = (__v_0 - __v_11); let __v_13: G = G::from_u64(64); let __v_14: G = (__v_12 * __v_13); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_14 + __v_15); - let __ret: [G; OUT_215] = [__v_16, __v_10]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_16, __v_10]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -20995,11 +21583,11 @@ fn aiur_fn_215( let __v_17: G = (__v_0 - __v_16); let __v_18: G = G::from_u64(4096); let __v_19: G = (__v_17 * __v_18); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(64); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_22 + __v_23); let __v_25: G = (__v_19 + __v_24); @@ -21007,8 +21595,8 @@ fn aiur_fn_215( let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_27.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_215] = [__v_25, __v_15]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_25, __v_15]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21049,15 +21637,15 @@ fn aiur_fn_215( let __v_20: G = (__v_0 - __v_19); let __v_21: G = G::from_u64(262144); let __v_22: G = (__v_20 * __v_21); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(4096); let __v_25: G = (__v_23 * __v_24); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(64); let __v_28: G = (__v_26 * __v_27); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_214(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_28 + __v_29); let __v_31: G = (__v_25 + __v_30); @@ -21066,8 +21654,8 @@ fn aiur_fn_215( let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_34.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_215] = [__v_32, __v_18]; - if let Some(result) = record.function_queries[215].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_227] = [__v_32, __v_18]; + if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21103,15 +21691,15 @@ fn aiur_fn_215( }) } -const INPUT_SIZE_216: usize = 1; -const IN_216: usize = 1; -const OUT_216: usize = 1; -fn aiur_fn_216( - inp: [G; IN_216], +const INPUT_SIZE_228: usize = 1; +const IN_228: usize = 1; +const OUT_228: usize = 1; +fn aiur_fn_228( + inp: [G; IN_228], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_216], ExecError> { +) -> Result<[G; OUT_228], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -21123,17 +21711,17 @@ fn aiur_fn_216( let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_3, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_9: G = G::from_u64(2); - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_8, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(2); - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_200(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_212(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); @@ -21141,7 +21729,7 @@ fn aiur_fn_216( let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_17, __v_18, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); @@ -21149,7 +21737,7 @@ fn aiur_fn_216( let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_24, __v_25, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(2); - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_196(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); @@ -21162,26 +21750,26 @@ fn aiur_fn_216( let __v_41: G = G::from_u64(3); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_41, __v_16, __v_23, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(3); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_45, __v_37, __v_44, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_216] = [__v_47]; - if let Some(result) = record.function_queries[216].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_228] = [__v_47]; + if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_217: usize = 4; -const IN_217: usize = 4; -const OUT_217: usize = 1; -fn aiur_fn_217( - inp: [G; IN_217], +const INPUT_SIZE_229: usize = 4; +const IN_229: usize = 4; +const OUT_229: usize = 1; +fn aiur_fn_229( + inp: [G; IN_229], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_217], ExecError> { +) -> Result<[G; OUT_229], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21193,15 +21781,15 @@ fn aiur_fn_217( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_217] = [__v_1]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_229] = [__v_1]; + if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_215(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_221(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_221] = unsafe { *(result.output.as_ptr() as *const [G; OUT_221]) }; __ret } } else { aiur_fn_221(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(7); let __v_11: G = G::from_u64(0); @@ -21213,13 +21801,13 @@ fn aiur_fn_217( 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_217] = { let __args: [G; IN_217] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_217(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_229(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); let __v_23: G = { let __values: [G; 4] = [__v_21, __v_19, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_217] = [__v_23]; - if let Some(result) = record.function_queries[217].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_229] = [__v_23]; + if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21229,15 +21817,15 @@ fn aiur_fn_217( }) } -const INPUT_SIZE_218: usize = 2; -const IN_218: usize = 2; -const OUT_218: usize = 1; -fn aiur_fn_218( - inp: [G; IN_218], +const INPUT_SIZE_230: usize = 2; +const IN_230: usize = 2; +const OUT_230: usize = 1; +fn aiur_fn_230( + inp: [G; IN_230], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_218], ExecError> { +) -> Result<[G; OUT_230], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21255,7 +21843,7 @@ fn aiur_fn_218( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -21275,7 +21863,7 @@ fn aiur_fn_218( 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_314] = { let __args: [G; IN_314] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_14, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -21285,58 +21873,58 @@ fn aiur_fn_218( match __v_27.as_canonical_u64() { 4u64 => { let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_32, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_218] = [__v_33]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_33]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_31: G = G::from_u64(3); let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_31, __v_26, __v_4, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_33, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_218] = [__v_34]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_34]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_218] = [__v_0]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_0]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_218] = [__v_0]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_0]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_218] = [__v_0]; - if let Some(result) = record.function_queries[218].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_230] = [__v_0]; + if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_219: usize = 2; -const IN_219: usize = 2; -const OUT_219: usize = 1; -fn aiur_fn_219( - inp: [G; IN_219], +const INPUT_SIZE_231: usize = 2; +const IN_231: usize = 2; +const OUT_231: usize = 1; +fn aiur_fn_231( + inp: [G; IN_231], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_219], ExecError> { +) -> Result<[G; OUT_231], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21349,39 +21937,39 @@ fn aiur_fn_219( 7u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_219] = [__v_7]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_7]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_219] = [__v_0]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_0]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_219] = [__v_0]; - if let Some(result) = record.function_queries[219].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_231] = [__v_0]; + if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_220: usize = 1; -const IN_220: usize = 1; -const OUT_220: usize = 4; -fn aiur_fn_220( - inp: [G; IN_220], +const INPUT_SIZE_232: usize = 1; +const IN_232: usize = 1; +const OUT_232: usize = 4; +fn aiur_fn_232( + inp: [G; IN_232], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_220], ExecError> { +) -> Result<[G; OUT_232], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -21400,24 +21988,24 @@ fn aiur_fn_220( let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_122(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_220] = [__v_2, __v_5, __v_8, __v_11]; - if let Some(result) = record.function_queries[220].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_232] = [__v_2, __v_5, __v_8, __v_11]; + if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_221: usize = 1; -const IN_221: usize = 1; -const OUT_221: usize = 1; -fn aiur_fn_221( - inp: [G; IN_221], +const INPUT_SIZE_233: usize = 1; +const IN_233: usize = 1; +const OUT_233: usize = 1; +fn aiur_fn_233( + inp: [G; IN_233], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_221], ExecError> { +) -> Result<[G; OUT_233], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -21451,25 +22039,25 @@ fn aiur_fn_221( 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_221] = [__v_30]; - if let Some(result) = record.function_queries[221].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_233] = [__v_30]; + if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_222: usize = 2; -const IN_222: usize = 2; -const OUT_222: usize = 2; -fn aiur_fn_222( - inp: [G; IN_222], +const INPUT_SIZE_234: usize = 2; +const IN_234: usize = 2; +const OUT_234: usize = 2; +fn aiur_fn_234( + inp: [G; IN_234], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_222], ExecError> { +) -> Result<[G; OUT_234], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -21481,13 +22069,13 @@ fn aiur_fn_222( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_210(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { @@ -21495,8 +22083,8 @@ fn aiur_fn_222( 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_222] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_12, __v_15]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21504,14 +22092,14 @@ fn aiur_fn_222( 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_222] = [__v_12, __v_15]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_12, __v_15]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_199(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -21521,19 +22109,19 @@ fn aiur_fn_222( 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_222] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_13, __v_16]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 3u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { @@ -21542,30 +22130,30 @@ fn aiur_fn_222( let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_18, __v_21]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_18, __v_21]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_18: G = G::from_u64(2); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_222(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_222] = unsafe { *(result.output.as_ptr() as *const [G; OUT_222]) }; __ret } } else { aiur_fn_222(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_222] = [__v_22, __v_21]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_22, __v_21]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_22: G = G::from_u64(1); - let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_222] = [__v_22, __v_23]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_22, __v_23]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21583,8 +22171,8 @@ fn aiur_fn_222( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_222] = [__v_14, __v_17]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_14, __v_17]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21598,59 +22186,59 @@ fn aiur_fn_222( 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_222] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[222].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_234] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_223: usize = 2; -const IN_223: usize = 2; -const OUT_223: usize = 2; -fn aiur_fn_223( - inp: [G; IN_223], +const INPUT_SIZE_235: usize = 2; +const IN_235: usize = 2; +const OUT_235: usize = 2; +fn aiur_fn_235( + inp: [G; IN_235], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_223], ExecError> { +) -> Result<[G; OUT_235], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_223] = [__v_4, __v_3]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_235] = [__v_4, __v_3]; + if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_224(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_224] = unsafe { *(result.output.as_ptr() as *const [G; OUT_224]) }; __ret } } else { aiur_fn_224(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_223] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[223].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_235] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_224: usize = 1; -const IN_224: usize = 1; -const OUT_224: usize = 2; -fn aiur_fn_224( - inp: [G; IN_224], +const INPUT_SIZE_236: usize = 1; +const IN_236: usize = 1; +const OUT_236: usize = 2; +fn aiur_fn_236( + inp: [G; IN_236], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_224], ExecError> { +) -> Result<[G; OUT_236], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -21667,7 +22255,7 @@ fn aiur_fn_224( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_209(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -21675,8 +22263,8 @@ fn aiur_fn_224( 0u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_224] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21689,18 +22277,18 @@ fn aiur_fn_224( 7u64 => { match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_225(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_224] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_224] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21708,8 +22296,8 @@ fn aiur_fn_224( _ => { let __v_15: G = G::from_u64(0); let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_224] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21719,8 +22307,8 @@ fn aiur_fn_224( _ => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_224] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21728,23 +22316,23 @@ fn aiur_fn_224( _ => { let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_224] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[224].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_236] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_225: usize = 1; -const IN_225: usize = 1; -const OUT_225: usize = 2; -fn aiur_fn_225( - inp: [G; IN_225], +const INPUT_SIZE_237: usize = 1; +const IN_237: usize = 1; +const OUT_237: usize = 2; +fn aiur_fn_237( + inp: [G; IN_237], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_225], ExecError> { +) -> Result<[G; OUT_237], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -21782,8 +22370,8 @@ fn aiur_fn_225( 0u64 => { let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_225] = [__v_26, __v_27]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_26, __v_27]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21798,8 +22386,8 @@ fn aiur_fn_225( match __v_33.as_canonical_u64() { 1u64 => { let __v_34: G = G::from_u64(1); - let __ret: [G; OUT_225] = [__v_34, __v_31]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_34, __v_31]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21809,8 +22397,8 @@ fn aiur_fn_225( 0u64 => { let __v_36: G = G::from_u64(0); let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_225] = [__v_36, __v_37]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_36, __v_37]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21819,15 +22407,15 @@ fn aiur_fn_225( match __v_37.as_canonical_u64() { 1u64 => { let __v_38: G = G::from_u64(1); - let __ret: [G; OUT_225] = [__v_38, __v_31]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_38, __v_31]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(0); let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_225] = [__v_38, __v_39]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_38, __v_39]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21841,8 +22429,8 @@ fn aiur_fn_225( _ => { let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_225] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -21850,23 +22438,23 @@ fn aiur_fn_225( _ => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_225] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[225].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_237] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_226: usize = 2; -const IN_226: usize = 2; -const OUT_226: usize = 2; -fn aiur_fn_226( - inp: [G; IN_226], +const INPUT_SIZE_238: usize = 2; +const IN_238: usize = 2; +const OUT_238: usize = 2; +fn aiur_fn_238( + inp: [G; IN_238], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_226], ExecError> { +) -> Result<[G; OUT_238], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -21874,8 +22462,8 @@ fn aiur_fn_226( 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_226] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -21883,59 +22471,59 @@ fn aiur_fn_226( 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_226] = { let __args: [G; IN_226] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_226] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[226].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_238] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_227: usize = 1; -const IN_227: usize = 1; -const OUT_227: usize = 4; -fn aiur_fn_227( - inp: [G; IN_227], +const INPUT_SIZE_239: usize = 1; +const IN_239: usize = 1; +const OUT_239: usize = 4; +fn aiur_fn_239( + inp: [G; IN_239], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_227], ExecError> { +) -> Result<[G; OUT_239], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_226(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_227] = [__v_2, __v_5, __v_8, __v_9]; - if let Some(result) = record.function_queries[227].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_239] = [__v_2, __v_5, __v_8, __v_9]; + if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_228: usize = 2; -const IN_228: usize = 2; -const OUT_228: usize = 1; -fn aiur_fn_228( - inp: [G; IN_228], +const INPUT_SIZE_240: usize = 2; +const IN_240: usize = 2; +const OUT_240: usize = 1; +fn aiur_fn_240( + inp: [G; IN_240], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_228], ExecError> { +) -> Result<[G; OUT_240], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_227(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_227] = unsafe { *(result.output.as_ptr() as *const [G; OUT_227]) }; __ret } } else { aiur_fn_227(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -21990,8 +22578,8 @@ fn aiur_fn_228( 1u64 => { let __v_37: G = G::from_u64(0); let __v_38: G = { let __values: [G; 3] = [__v_37, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_228] = [__v_38]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_38]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22007,8 +22595,8 @@ fn aiur_fn_228( let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 3] = [__v_44, __v_40, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = { let __values: [G; 3] = [__v_43, __v_42, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_228] = [__v_46]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_46]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22028,8 +22616,8 @@ fn aiur_fn_228( let __v_50: G = { let __values: [G; 3] = [__v_49, __v_42, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_51: G = { let __values: [G; 3] = [__v_48, __v_44, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_52: G = { let __values: [G; 3] = [__v_47, __v_46, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_228] = [__v_52]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_52]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22049,8 +22637,8 @@ fn aiur_fn_228( let __v_54: G = { let __values: [G; 3] = [__v_51, __v_44, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_55: G = { let __values: [G; 3] = [__v_50, __v_46, __v_54]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_56: G = { let __values: [G; 3] = [__v_49, __v_48, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_228] = [__v_56]; - if let Some(result) = record.function_queries[228].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_240] = [__v_56]; + if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22061,15 +22649,15 @@ fn aiur_fn_228( }) } -const INPUT_SIZE_229: usize = 1; -const IN_229: usize = 1; -const OUT_229: usize = 1; -fn aiur_fn_229( - inp: [G; IN_229], +const INPUT_SIZE_241: usize = 1; +const IN_241: usize = 1; +const OUT_241: usize = 1; +fn aiur_fn_241( + inp: [G; IN_241], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_229], ExecError> { +) -> Result<[G; OUT_241], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; @@ -22079,8 +22667,8 @@ fn aiur_fn_229( match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_229] = [__v_3]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_3]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22091,182 +22679,182 @@ fn aiur_fn_229( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_229] = [__v_5]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_5]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_229] = [__v_7]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_7]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_229] = [__v_9]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_9]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_229] = [__v_11]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_11]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_229] = [__v_13]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_13]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_229] = [__v_15]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_15]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_229] = [__v_17]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_17]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_229] = [__v_19]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_19]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_229] = [__v_21]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_21]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); - let __ret: [G; OUT_229] = [__v_23]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_23]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; match __v_24.as_canonical_u64() { 1u64 => { let __v_25: G = G::from_u64(1); - let __ret: [G; OUT_229] = [__v_25]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_25]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; match __v_26.as_canonical_u64() { 1u64 => { let __v_27: G = G::from_u64(1); - let __ret: [G; OUT_229] = [__v_27]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_27]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __ret: [G; OUT_229] = [__v_29]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_29]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; match __v_30.as_canonical_u64() { 1u64 => { let __v_31: G = G::from_u64(1); - let __ret: [G; OUT_229] = [__v_31]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_31]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; match __v_32.as_canonical_u64() { 1u64 => { let __v_33: G = G::from_u64(1); - let __ret: [G; OUT_229] = [__v_33]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_33]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __ret: [G; OUT_229] = [__v_33]; - if let Some(result) = record.function_queries[229].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_241] = [__v_33]; + if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22303,191 +22891,1204 @@ fn aiur_fn_229( }) } -const INPUT_SIZE_230: usize = 1; -const IN_230: usize = 1; -const OUT_230: usize = 2; -fn aiur_fn_230( - inp: [G; IN_230], +const INPUT_SIZE_242: usize = 1; +const IN_242: usize = 1; +const OUT_242: usize = 1; +fn aiur_fn_242( + inp: [G; IN_242], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_242], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + 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_8 + __v_25); + let __v_27: G = (__v_6 + __v_26); + let __v_28: G = (__v_4 + __v_27); + let __v_29: G = (__v_2 + __v_28); + let __ret: [G; OUT_242] = [__v_29]; + if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_243: usize = 1; +const IN_243: usize = 1; +const OUT_243: usize = 2; +fn aiur_fn_243( + inp: [G; IN_243], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_243], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + 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_243] = [__v_5, __v_3]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_243] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + 2u64 => { + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_7, __v_10]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + 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_243] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + 3u64 => { + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_243] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_243] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_244: usize = 2; +const IN_244: usize = 2; +const OUT_244: usize = 2; +fn aiur_fn_244( + inp: [G; IN_244], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_244], 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_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_244] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + 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_244] = [__v_10, __v_13]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + 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 __ret: [G; OUT_244] = [__v_8, __v_11]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + 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_244] = [__v_6, __v_9]; + if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_245: usize = 1; +const IN_245: usize = 1; +const OUT_245: usize = 1; +fn aiur_fn_245( + inp: [G; IN_245], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_245], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(7); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_245] = [__v_4]; + if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_246: usize = 1; +const IN_246: usize = 1; +const OUT_246: usize = 3; +fn aiur_fn_246( + inp: [G; IN_246], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_246], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + match __v_1.as_canonical_u64() { + 3u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_246] = [__v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __ret: [G; OUT_246] = [__v_15, __v_16, __v_18]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + 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 __ret: [G; OUT_246] = [__v_15, __v_16, __v_19]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }, + _ => { + 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 = 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_246] = [__v_11, __v_12, __v_15]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + 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 __ret: [G; OUT_246] = [__v_9, __v_10, __v_13]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + 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; 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_246] = [__v_5, __v_6, __v_9]; + if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_247: usize = 2; +const IN_247: usize = 2; +const OUT_247: usize = 1; +fn aiur_fn_247( + inp: [G; IN_247], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_247], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = (__v_3 - __v_4); + let __v_6: G = (__v_0 * __v_5); + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + break '__mc_0 [__v_7]; + }, + _ => { + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + break '__mc_0 [__v_7]; + }, +} + }; + let __v_7: G = __mc_out___mc_0[0]; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_6.as_canonical_u64() { + 0u64 => { + break '__mc_1 [__v_2]; + }, + _ => { + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + break '__mc_1 [__v_9]; + }, +} + }; + let __v_8: G = __mc_out___mc_1[0]; + let __v_9: G = G::from_u64(3); + 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_7, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 4] = [__v_9, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_247] = [__v_18]; + if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }) +} + +const INPUT_SIZE_248: usize = 4; +const IN_248: usize = 4; +const OUT_248: usize = 1; +fn aiur_fn_248( + inp: [G; IN_248], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_248], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = (__v_0 - __v_2); + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_248] = [__v_6]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_248] = [__v_7]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_248] = [__v_7]; + if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_249: usize = 3; +const IN_249: usize = 3; +const OUT_249: usize = 1; +fn aiur_fn_249( + inp: [G; IN_249], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_249], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_249] = [__v_4]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = (__v_5 - __v_6); + let __v_8: G = (__v_0 * __v_7); + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_249] = [__v_11]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_249] = [__v_10]; + if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_250: usize = 4; +const IN_250: usize = 4; +const OUT_250: usize = 1; +fn aiur_fn_250( + inp: [G; IN_250], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_250], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_250] = [__v_9]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = (__v_7 - __v_8); + let __v_10: G = (__v_0 * __v_9); + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + break '__mc_0 [__v_11]; + }, + _ => { + break '__mc_0 [__v_5]; + }, +} + }; + let __v_11: G = __mc_out___mc_0[0]; + let __v_12: G = G::from_u64(2); + let __v_13: G = (__v_0 * __v_2); + let __v_14: G = (__v_12 * __v_13); + let __v_15: G = (__v_2 - __v_14); + let __v_16: G = (__v_0 + __v_15); + let __v_17: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = (__v_17 - __v_18); + let __v_20: G = (__v_16 * __v_19); + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_20, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_250] = [__v_21]; + if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_251: usize = 3; +const IN_251: usize = 3; +const OUT_251: usize = 1; +fn aiur_fn_251( + inp: [G; IN_251], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_251], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_251] = [__v_4]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = (__v_5 - __v_6); + let __v_8: G = (__v_0 * __v_7); + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + break '__mc_0 [__v_9]; + }, + _ => { + break '__mc_0 [__v_4]; + }, +} + }; + let __v_9: G = __mc_out___mc_0[0]; + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(2); + let __v_12: G = G::from_u64(0); + let __v_13: G = 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(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 __v_22: G = { let __values: [G; 10] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_23, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_24, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __v_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_119] = { let __args: [G; IN_119] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __ret: [G; OUT_251] = [__v_28]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __ret: [G; OUT_251] = [__v_27]; + if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_252: usize = 3; +const IN_252: usize = 3; +const OUT_252: usize = 1; +fn aiur_fn_252( + inp: [G; IN_252], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_252], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_252] = [__v_8]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = (__v_5 - __v_6); + let __v_8: G = (__v_0 * __v_7); + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_119(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + break '__mc_0 [__v_9]; + }, + _ => { + break '__mc_0 [__v_4]; + }, +} + }; + let __v_9: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = (__v_11 - __v_12); + let __v_14: G = (__v_0 * __v_13); + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_14.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + break '__mc_1 [__v_15]; + }, + _ => { + break '__mc_1 [__v_10]; + }, +} + }; + let __v_15: G = __mc_out___mc_1[0]; + let __v_16: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = (__v_16 - __v_17); + let __v_19: G = (__v_0 * __v_18); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(2); + 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(1); + let __v_30: G = G::from_u64(1); + let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_33, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_131(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_34, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + match __v_35.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __ret: [G; OUT_252] = [__v_36]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(1); + 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(1); + let __v_47: G = G::from_u64(1); + let __v_48: G = { let __values: [G; 10] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_48]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __ret: [G; OUT_252] = [__v_50]; + if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_253: usize = 3; +const IN_253: usize = 3; +const OUT_253: usize = 2; +fn aiur_fn_253( + inp: [G; IN_253], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_253], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = (__v_6 + __v_8); + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + 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_253] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + match __v_14.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + break '__mc_0 [__v_19]; + }, + _ => { + let __v_19: G = G::from_u64(1); + let __v_20: G = (__v_19 - __v_15); + let __v_21: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = (__v_21 - __v_22); + let __v_24: G = (__v_20 * __v_23); + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_24, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + break '__mc_0 [__v_25]; + }, +} + }; + let __v_19: G = __mc_out___mc_0[0]; + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_253] = [__v_20, __v_23]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + 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_253] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_10: G = G::from_u64(2); + let __v_11: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + 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_253] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + match __v_14.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __ret: [G; OUT_253] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + 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_253] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_254: usize = 4; +const IN_254: usize = 4; +const OUT_254: usize = 2; +fn aiur_fn_254( + inp: [G; IN_254], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_230], ExecError> { +) -> Result<[G; OUT_254], 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_230] = [__v_5, __v_3]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - let __v_5: G = G::from_u64(0); - let __v_6: G = G::from_u64(1); - let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_230] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - } - }, - 2u64 => { - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_143(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - match __v_6.as_canonical_u64() { + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = (__v_7 + __v_9); + let __v_11: G = (__v_5 + __v_10); + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + match __v_14.as_canonical_u64() { 1u64 => { - let __v_7: G = G::from_u64(1); - let __v_8: G = G::from_u64(1); - let __v_9: G = G::from_u64(1); - let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_230] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_17.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + break '__mc_0 [__v_18]; + }, + _ => { + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + match __v_19.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + break '__mc_0 [__v_20]; + }, + _ => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(2); + 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(1); + let __v_30: G = G::from_u64(1); + let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = G::from_u64(1); + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_15, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_132(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = (__v_33 - __v_35); + let __v_37: G = (__v_2 * __v_36); + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_134(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + break '__mc_0 [__v_39]; + }, + } + }, +} + }; + let __v_18: G = __mc_out___mc_0[0]; + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(2); + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_254] = [__v_19, __v_22]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - 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_230] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_254] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, - 3u64 => { - let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_230] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, _ => { - let __v_5: G = G::from_u64(0); - let __v_6: G = G::from_u64(1); - let __v_7: G = G::from_u64(1); - let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_230] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[230].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __v_12: G = G::from_u64(1); + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + match __v_14.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_18.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + break '__mc_1 [__v_19]; + }, + _ => { + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __v_21: G = G::from_u64(1); + let __v_22: G = (__v_21 - __v_15); + let __v_23: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = (__v_23 - __v_24); + let __v_26: G = (__v_22 * __v_25); + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + break '__mc_1 [__v_27]; }, - } - }) -} - -const INPUT_SIZE_231: usize = 2; -const IN_231: usize = 2; -const OUT_231: usize = 2; -fn aiur_fn_231( - inp: [G; IN_231], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_231], 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_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; - let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; - let __v_7: G = __r_arr[0]; - match __v_7.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __v_9: G = __r_arr[1]; - match __v_8.as_canonical_u64() { + let __v_23: G = G::from_u64(2); + let __v_24: G = (__v_2 * __v_15); + let __v_25: G = (__v_23 * __v_24); + let __v_26: G = (__v_15 - __v_25); + let __v_27: G = (__v_2 + __v_26); + let __v_28: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = (__v_28 - __v_29); + let __v_31: G = G::from_u64(1); + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = (__v_31 - __v_32); + let __v_34: G = (__v_30 * __v_33); + let __v_35: G = (__v_27 * __v_34); + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_125(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + break '__mc_1 [__v_37]; + }, + _ => { + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + match __v_24.as_canonical_u64() { 1u64 => { - let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; - let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_231] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + break '__mc_1 [__v_25]; }, _ => { - let __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_231] = [__v_10, __v_13]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + break '__mc_1 [__v_25]; }, } }, + } + }, + } + }, +} + }; + let __v_19: G = __mc_out___mc_1[0]; + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(2); + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_254] = [__v_20, __v_23]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, _ => { - 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 __ret: [G; OUT_231] = [__v_8, __v_11]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __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_254] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, - _ => { - 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_231] = [__v_6, __v_9]; - if let Some(result) = record.function_queries[231].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, } }) } -const INPUT_SIZE_232: usize = 1; -const IN_232: usize = 1; -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 = 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_232] = [__v_4]; - if let Some(result) = record.function_queries[232].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_233: usize = 2; -const IN_233: usize = 2; -const OUT_233: usize = 1; -fn aiur_fn_233( - inp: [G; IN_233], +const INPUT_SIZE_255: usize = 2; +const IN_255: usize = 2; +const OUT_255: usize = 1; +fn aiur_fn_255( + inp: [G; IN_255], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_233], ExecError> { +) -> Result<[G; OUT_255], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -22497,18 +24098,18 @@ fn aiur_fn_233( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_233] = [__v_0]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_0]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(3); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_5, __v_0, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_233] = [__v_8]; - if let Some(result) = record.function_queries[233].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_255] = [__v_8]; + if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22518,20 +24119,20 @@ fn aiur_fn_233( }) } -const INPUT_SIZE_234: usize = 3; -const IN_234: usize = 3; -const OUT_234: usize = 2; -fn aiur_fn_234( - inp: [G; IN_234], +const INPUT_SIZE_256: usize = 3; +const IN_256: usize = 3; +const OUT_256: usize = 2; +fn aiur_fn_256( + inp: [G; IN_256], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_234], ExecError> { +) -> Result<[G; OUT_256], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; @@ -22542,14 +24143,14 @@ fn aiur_fn_234( let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_5, __v_8]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_5, __v_8]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -22560,14 +24161,14 @@ fn aiur_fn_234( let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -22578,14 +24179,14 @@ fn aiur_fn_234( let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_9, __v_12]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_9, __v_12]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -22596,14 +24197,14 @@ fn aiur_fn_234( let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_11, __v_14]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_11, __v_14]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -22614,14 +24215,14 @@ fn aiur_fn_234( let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_13, __v_16]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_13, __v_16]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -22632,14 +24233,14 @@ fn aiur_fn_234( let __v_16: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_15, __v_18]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_15, __v_18]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; @@ -22650,14 +24251,14 @@ fn aiur_fn_234( let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_17, __v_20]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; @@ -22668,14 +24269,14 @@ fn aiur_fn_234( let __v_20: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_19, __v_22]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_19, __v_22]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; @@ -22686,14 +24287,14 @@ fn aiur_fn_234( let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_21, __v_24]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; @@ -22704,14 +24305,14 @@ fn aiur_fn_234( let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_23, __v_26]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_23, __v_26]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; @@ -22722,14 +24323,14 @@ fn aiur_fn_234( let __v_26: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_25, __v_28]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_25, __v_28]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; @@ -22740,30 +24341,30 @@ fn aiur_fn_234( let __v_28: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_27, __v_30]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_27, __v_30]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; match __v_28.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_29, __v_31]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_29, __v_31]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; @@ -22772,10 +24373,10 @@ fn aiur_fn_234( let __v_31: G = G::from_u64(1); let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_120(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_198(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_234] = [__v_31, __v_33]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_31, __v_33]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22784,8 +24385,8 @@ fn aiur_fn_234( let __v_33: G = G::from_u64(0); let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 4] = [__v_32, __v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_234] = [__v_31, __v_35]; - if let Some(result) = record.function_queries[234].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_256] = [__v_31, __v_35]; + if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22818,15 +24419,15 @@ fn aiur_fn_234( }) } -const INPUT_SIZE_235: usize = 2; -const IN_235: usize = 2; -const OUT_235: usize = 3; -fn aiur_fn_235( - inp: [G; IN_235], +const INPUT_SIZE_257: usize = 2; +const IN_257: usize = 2; +const OUT_257: usize = 3; +fn aiur_fn_257( + inp: [G; IN_257], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_235], ExecError> { +) -> Result<[G; OUT_257], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -22837,7 +24438,7 @@ fn aiur_fn_235( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -22847,22 +24448,22 @@ fn aiur_fn_235( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_235] = [__v_8, __v_0, __v_11]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_8, __v_0, __v_11]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(2); let __v_10: G = (__v_8 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -22874,8 +24475,8 @@ fn aiur_fn_235( match __v_16.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(1); - let __ret: [G; OUT_235] = [__v_19, __v_12, __v_17]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_19, __v_12, __v_17]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -22883,8 +24484,8 @@ fn aiur_fn_235( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_235] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22894,8 +24495,8 @@ fn aiur_fn_235( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_235] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22905,8 +24506,8 @@ fn aiur_fn_235( 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_235] = [__v_11, __v_0, __v_14]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_11, __v_0, __v_14]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -22918,23 +24519,23 @@ fn aiur_fn_235( 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_235] = [__v_6, __v_0, __v_9]; - if let Some(result) = record.function_queries[235].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_257] = [__v_6, __v_0, __v_9]; + if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_236: usize = 2; -const IN_236: usize = 2; -const OUT_236: usize = 1; -fn aiur_fn_236( - inp: [G; IN_236], +const INPUT_SIZE_258: usize = 2; +const IN_258: usize = 2; +const OUT_258: usize = 1; +fn aiur_fn_258( + inp: [G; IN_258], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_236], ExecError> { +) -> Result<[G; OUT_258], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -22970,13 +24571,13 @@ fn aiur_fn_236( let __v_25: G = G::from_u64(3); let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_236] = [__v_27]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_27]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); @@ -22996,23 +24597,23 @@ fn aiur_fn_236( let __v_42: G = G::from_u64(3); let __v_43: G = G::from_u64(0); let __v_44: G = { let __values: [G; 4] = [__v_42, __v_23, __v_41, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_236] = [__v_44]; - if let Some(result) = record.function_queries[236].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_258] = [__v_44]; + if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_237: usize = 1; -const IN_237: usize = 1; -const OUT_237: usize = 1; -fn aiur_fn_237( - inp: [G; IN_237], +const INPUT_SIZE_259: usize = 1; +const IN_259: usize = 1; +const OUT_259: usize = 1; +fn aiur_fn_259( + inp: [G; IN_259], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_237], ExecError> { +) -> Result<[G; OUT_259], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -23022,8 +24623,8 @@ fn aiur_fn_237( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 7u64 => { - let __ret: [G; OUT_237] = [__v_0]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_0]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23037,7 +24638,7 @@ fn aiur_fn_237( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_235(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -23049,29 +24650,29 @@ fn aiur_fn_237( let __v_15: G = __r_arr[0]; match __v_15.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_237] = [__v_0]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_0]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_236(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_237] = [__v_16]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_16]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_237] = [__v_0]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_0]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_237] = [__v_0]; - if let Some(result) = record.function_queries[237].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_259] = [__v_0]; + if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23080,15 +24681,15 @@ fn aiur_fn_237( }) } -const INPUT_SIZE_238: usize = 3; -const IN_238: usize = 3; -const OUT_238: usize = 2; -fn aiur_fn_238( - inp: [G; IN_238], +const INPUT_SIZE_260: usize = 3; +const IN_260: usize = 3; +const OUT_260: usize = 2; +fn aiur_fn_260( + inp: [G; IN_260], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_238], ExecError> { +) -> Result<[G; OUT_260], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23098,15 +24699,15 @@ fn aiur_fn_238( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_238] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); @@ -23117,30 +24718,30 @@ fn aiur_fn_238( let __v_12: G = G::from_u64(3); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_12, __v_10, __v_0, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __v_17: G = { let __values: [G; 4] = [__v_11, __v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_238] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[238].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_260] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_239: usize = 1; -const IN_239: usize = 1; -const OUT_239: usize = 1; -fn aiur_fn_239( - inp: [G; IN_239], +const INPUT_SIZE_261: usize = 1; +const IN_261: usize = 1; +const OUT_261: usize = 1; +fn aiur_fn_261( + inp: [G; IN_261], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_239], ExecError> { +) -> Result<[G; OUT_261], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -23174,19 +24775,19 @@ fn aiur_fn_239( match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_239] = [__v_17]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_17]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; @@ -23196,22 +24797,22 @@ fn aiur_fn_239( match __v_22.as_canonical_u64() { 0u64 => { let __v_26: G = G::from_bool((__v_23 == G::ZERO)); - let __ret: [G; OUT_239] = [__v_26]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_26]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(0); - let __ret: [G; OUT_239] = [__v_26]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_26]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_239] = [__v_20]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_20]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23220,39 +24821,39 @@ fn aiur_fn_239( }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_239] = [__v_15]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_15]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_239] = [__v_9]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_9]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_239] = [__v_5]; - if let Some(result) = record.function_queries[239].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_261] = [__v_5]; + if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_240: usize = 5; -const IN_240: usize = 5; -const OUT_240: usize = 2; -fn aiur_fn_240( - inp: [G; IN_240], +const INPUT_SIZE_262: usize = 5; +const IN_262: usize = 5; +const OUT_262: usize = 2; +fn aiur_fn_262( + inp: [G; IN_262], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_240], ExecError> { +) -> Result<[G; OUT_262], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23268,14 +24869,14 @@ fn aiur_fn_240( 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_240] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -23285,17 +24886,17 @@ fn aiur_fn_240( 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_240] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = (__v_1 + __v_2); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_10 + __v_11); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_239(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_239] = unsafe { *(result.output.as_ptr() as *const [G; OUT_239]) }; __ret } } else { aiur_fn_239(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { @@ -23304,18 +24905,18 @@ fn aiur_fn_240( 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_240] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_4 + __v_16); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { @@ -23323,20 +24924,20 @@ fn aiur_fn_240( let __v_21: G = G::from_u64(1); let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_20, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_23, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_240] = [__v_21, __v_24]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_21, __v_24]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_240] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[240].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_262] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23352,20 +24953,20 @@ fn aiur_fn_240( }) } -const INPUT_SIZE_241: usize = 3; -const IN_241: usize = 3; -const OUT_241: usize = 2; -fn aiur_fn_241( - inp: [G; IN_241], +const INPUT_SIZE_263: usize = 3; +const IN_263: usize = 3; +const OUT_263: usize = 2; +fn aiur_fn_263( + inp: [G; IN_263], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_241], ExecError> { +) -> Result<[G; OUT_263], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; @@ -23386,31 +24987,31 @@ fn aiur_fn_241( 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_241] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_241] = [__v_16, __v_19]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_16, __v_19]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23419,8 +25020,8 @@ fn aiur_fn_241( 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_241] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23439,33 +25040,33 @@ fn aiur_fn_241( 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_241] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_241] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23474,8 +25075,8 @@ fn aiur_fn_241( 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_241] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23483,11 +25084,11 @@ fn aiur_fn_241( } }, _ => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_241] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[241].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_263] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23496,15 +25097,15 @@ fn aiur_fn_241( }) } -const INPUT_SIZE_242: usize = 3; -const IN_242: usize = 3; -const OUT_242: usize = 2; -fn aiur_fn_242( - inp: [G; IN_242], +const INPUT_SIZE_264: usize = 3; +const IN_264: usize = 3; +const OUT_264: usize = 2; +fn aiur_fn_264( + inp: [G; IN_264], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_242], ExecError> { +) -> Result<[G; OUT_264], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23518,40 +25119,40 @@ fn aiur_fn_242( 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_242] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_234(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_242] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23560,8 +25161,8 @@ fn aiur_fn_242( 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_242] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23572,23 +25173,23 @@ fn aiur_fn_242( 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_242] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_242] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23597,8 +25198,8 @@ fn aiur_fn_242( 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_242] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[242].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_264] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23609,29 +25210,29 @@ fn aiur_fn_242( }) } -const INPUT_SIZE_243: usize = 4; -const IN_243: usize = 4; -const OUT_243: usize = 2; -fn aiur_fn_243( - inp: [G; IN_243], +const INPUT_SIZE_265: usize = 4; +const IN_265: usize = 4; +const OUT_265: usize = 2; +fn aiur_fn_265( + inp: [G; IN_265], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_243], ExecError> { +) -> Result<[G; OUT_265], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -23658,24 +25259,24 @@ fn aiur_fn_243( 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_243] = [__v_22, __v_26]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_22, __v_26]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_238(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_238] = unsafe { *(result.output.as_ptr() as *const [G; OUT_238]) }; __ret } } else { aiur_fn_238(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; match __v_24.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(2); - let __ret: [G; OUT_243] = [__v_26, __v_25]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_26, __v_25]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23684,18 +25285,18 @@ fn aiur_fn_243( 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_243] = [__v_26, __v_30]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_26, __v_30]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_24: G = G::from_u64(2); - let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_244(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_243] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[243].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_265] = [__v_24, __v_25]; + if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23704,15 +25305,15 @@ fn aiur_fn_243( }) } -const INPUT_SIZE_244: usize = 4; -const IN_244: usize = 4; -const OUT_244: usize = 1; -fn aiur_fn_244( - inp: [G; IN_244], +const INPUT_SIZE_266: usize = 4; +const IN_266: usize = 4; +const OUT_266: usize = 1; +fn aiur_fn_266( + inp: [G; IN_266], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_244], ExecError> { +) -> Result<[G; OUT_266], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23728,27 +25329,27 @@ fn aiur_fn_244( let __v_11: G = G::from_u64(3); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_11, __v_9, __v_1, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_10, __v_13, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_244] = [__v_17]; - if let Some(result) = record.function_queries[244].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_266] = [__v_17]; + if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_245: usize = 10; -const IN_245: usize = 10; -const OUT_245: usize = 8; -fn aiur_fn_245( - inp: [G; IN_245], +const INPUT_SIZE_267: usize = 10; +const IN_267: usize = 10; +const OUT_267: usize = 8; +fn aiur_fn_267( + inp: [G; IN_267], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_245], ExecError> { +) -> Result<[G; OUT_267], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -23762,8 +25363,8 @@ fn aiur_fn_245( let __v_9: G = inp[9]; match __v_9.as_canonical_u64() { 8u64 => { - let __ret: [G; OUT_245] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23773,15 +25374,15 @@ fn aiur_fn_245( let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_245] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__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[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -23790,13 +25391,13 @@ fn aiur_fn_245( 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_245] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_13: G = G::from_u64(2); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__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[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -23805,13 +25406,13 @@ fn aiur_fn_245( 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_245] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_13: G = G::from_u64(3); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__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[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -23820,13 +25421,13 @@ fn aiur_fn_245( 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_245] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_13: G = G::from_u64(4); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__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[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -23835,13 +25436,13 @@ fn aiur_fn_245( 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_245] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_13: G = G::from_u64(5); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__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[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -23850,13 +25451,13 @@ fn aiur_fn_245( 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_245] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_13: G = G::from_u64(6); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__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[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -23865,13 +25466,13 @@ fn aiur_fn_245( 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_245] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_13: G = G::from_u64(7); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__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[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -23880,13 +25481,13 @@ fn aiur_fn_245( 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_245] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(8); - let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__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[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -23895,8 +25496,8 @@ fn aiur_fn_245( 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_245] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[245].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -23910,22 +25511,22 @@ fn aiur_fn_245( }) } -const INPUT_SIZE_246: usize = 2; -const IN_246: usize = 2; -const OUT_246: usize = 1; -fn aiur_fn_246( - inp: [G; IN_246], +const INPUT_SIZE_268: usize = 2; +const IN_268: usize = 2; +const OUT_268: usize = 1; +fn aiur_fn_268( + inp: [G; IN_268], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_246], ExecError> { +) -> Result<[G; OUT_268], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_246] = [__v_0]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_0]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23938,17 +25539,17 @@ fn aiur_fn_246( 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_246] = [__v_7]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_7]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 - __v_5); - let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_246] = [__v_7]; - if let Some(result) = record.function_queries[246].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_268] = [__v_7]; + if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -23960,15 +25561,15 @@ fn aiur_fn_246( }) } -const INPUT_SIZE_247: usize = 1; -const IN_247: usize = 1; -const OUT_247: usize = 1; -fn aiur_fn_247( - inp: [G; IN_247], +const INPUT_SIZE_269: usize = 1; +const IN_269: usize = 1; +const OUT_269: usize = 1; +fn aiur_fn_269( + inp: [G; IN_269], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_247], ExecError> { +) -> Result<[G; OUT_269], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -23980,7 +25581,7 @@ fn aiur_fn_247( 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_245] = { let __args: [G; IN_245] = [__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[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -23990,7 +25591,7 @@ fn aiur_fn_247( 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_246] = { let __args: [G; IN_246] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_246(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -24004,7 +25605,7 @@ fn aiur_fn_247( break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; break '__mc_0 [__v_23]; }, @@ -24031,8 +25632,8 @@ fn aiur_fn_247( let __v_35: G = G::from_u64(1); let __v_36: G = G::from_u64(1); let __v_37: G = { let __values: [G; 10] = [__v_35, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_247] = [__v_37]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_37]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -24041,8 +25642,8 @@ fn aiur_fn_247( let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 10] = [__v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_39: G = { let __values: [G; 10] = [__v_35, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_38]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_247] = [__v_39]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_39]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24053,23 +25654,23 @@ fn aiur_fn_247( _ => { let __v_34: G = G::from_u64(0); let __v_35: G = { let __values: [G; 10] = [__v_34, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_247] = [__v_35]; - if let Some(result) = record.function_queries[247].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_269] = [__v_35]; + if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_248: usize = 1; -const IN_248: usize = 1; -const OUT_248: usize = 1; -fn aiur_fn_248( - inp: [G; IN_248], +const INPUT_SIZE_270: usize = 1; +const IN_270: usize = 1; +const OUT_270: usize = 1; +fn aiur_fn_270( + inp: [G; IN_270], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_248], ExecError> { +) -> Result<[G; OUT_270], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr }; @@ -24087,40 +25688,40 @@ fn aiur_fn_248( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_248] = [__v_12]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_12]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_248] = [__v_13]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_13]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_248] = [__v_13]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_13]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_10: G = G::from_u64(3); - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_248] = [__v_13]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_13]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { @@ -24129,8 +25730,8 @@ fn aiur_fn_248( let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_248] = [__v_13]; - if let Some(result) = record.function_queries[248].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_270] = [__v_13]; + if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24140,15 +25741,15 @@ fn aiur_fn_248( }) } -const INPUT_SIZE_249: usize = 2; -const IN_249: usize = 2; -const OUT_249: usize = 1; -fn aiur_fn_249( - inp: [G; IN_249], +const INPUT_SIZE_271: usize = 2; +const IN_271: usize = 2; +const OUT_271: usize = 1; +fn aiur_fn_271( + inp: [G; IN_271], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_249], ExecError> { +) -> Result<[G; OUT_271], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24168,23 +25769,23 @@ fn aiur_fn_249( 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_249] = [__v_14]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_271] = [__v_14]; + if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_249] = [__v_17]; - if let Some(result) = record.function_queries[249].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_271] = [__v_17]; + if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24194,15 +25795,15 @@ fn aiur_fn_249( }) } -const INPUT_SIZE_250: usize = 5; -const IN_250: usize = 5; -const OUT_250: usize = 1; -fn aiur_fn_250( - inp: [G; IN_250], +const INPUT_SIZE_272: usize = 5; +const IN_272: usize = 5; +const OUT_272: usize = 1; +fn aiur_fn_272( + inp: [G; IN_272], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_250], ExecError> { +) -> Result<[G; OUT_272], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24232,15 +25833,15 @@ fn aiur_fn_250( 0u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); - let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_248(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_28]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_28]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -24249,139 +25850,139 @@ fn aiur_fn_250( let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_26]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_26]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_28]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_28]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_249(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(2); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_26, __v_24, __v_25, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_28]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_28]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(8); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = { let __values: [G; 4] = [__v_25, __v_24, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_28]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_28]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_211(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_223(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_223] = unsafe { *(result.output.as_ptr() as *const [G; OUT_223]) }; __ret } } else { aiur_fn_223(__args, record, io_buffer, __cu)? } }; let __v_26: G = G::from_u64(7); let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_29]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_29]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_247(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_247] = unsafe { *(result.output.as_ptr() as *const [G; OUT_247]) }; __ret } } else { aiur_fn_247(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(7); let __v_28: G = G::from_u64(0); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_30]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_30]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_23: G = G::from_u64(3); - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_27]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_27]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_27]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_27]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { let __v_23: G = G::from_u64(5); - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_27]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_27]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { let __v_23: G = G::from_u64(6); - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_250] = [__v_27]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_27]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 11u64 => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -24389,10 +25990,10 @@ fn aiur_fn_250( let __v_27: G = __loaded[2]; match __v_25.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_250] = [__v_28]; - if let Some(result) = record.function_queries[250].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_272] = [__v_28]; + if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24407,15 +26008,15 @@ fn aiur_fn_250( }) } -const INPUT_SIZE_251: usize = 17; -const IN_251: usize = 17; -const OUT_251: usize = 12; -fn aiur_fn_251( - inp: [G; IN_251], +const INPUT_SIZE_273: usize = 17; +const IN_273: usize = 17; +const OUT_273: usize = 12; +fn aiur_fn_273( + inp: [G; IN_273], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_251], ExecError> { +) -> Result<[G; OUT_273], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24436,9 +26037,9 @@ fn aiur_fn_251( let __v_16: G = inp[16]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; @@ -24446,8 +26047,8 @@ fn aiur_fn_251( 0u64 => { let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_251] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -24465,15 +26066,15 @@ fn aiur_fn_251( let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(3); let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_251] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_20: G = G::from_u64(2); let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_251] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; - if let Some(result) = record.function_queries[251].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; + if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24485,15 +26086,15 @@ fn aiur_fn_251( }) } -const INPUT_SIZE_252: usize = 14; -const IN_252: usize = 14; -const OUT_252: usize = 12; -fn aiur_fn_252( - inp: [G; IN_252], +const INPUT_SIZE_274: usize = 14; +const IN_274: usize = 14; +const OUT_274: usize = 12; +fn aiur_fn_274( + inp: [G; IN_274], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_252], ExecError> { +) -> Result<[G; OUT_274], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24511,29 +26112,29 @@ fn aiur_fn_252( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_252] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[252].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_274] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_253: usize = 14; -const IN_253: usize = 14; -const OUT_253: usize = 12; -fn aiur_fn_253( - inp: [G; IN_253], +const INPUT_SIZE_275: usize = 14; +const IN_275: usize = 14; +const OUT_275: usize = 12; +fn aiur_fn_275( + inp: [G; IN_275], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_253], ExecError> { +) -> Result<[G; OUT_275], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24551,29 +26152,29 @@ fn aiur_fn_253( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(4); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_253] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; - if let Some(result) = record.function_queries[253].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_275] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; + if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_254: usize = 1; -const IN_254: usize = 1; -const OUT_254: usize = 1; -fn aiur_fn_254( - inp: [G; IN_254], +const INPUT_SIZE_276: usize = 1; +const IN_276: usize = 1; +const OUT_276: usize = 1; +fn aiur_fn_276( + inp: [G; IN_276], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_254], ExecError> { +) -> Result<[G; OUT_276], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -24616,17 +26217,17 @@ fn aiur_fn_254( match __v_1.as_canonical_u64() { 1u64 => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_254] = [__v_37]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_276] = [__v_37]; + if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_37 + __v_38); - let __ret: [G; OUT_254] = [__v_39]; - if let Some(result) = record.function_queries[254].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_276] = [__v_39]; + if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -24636,15 +26237,15 @@ fn aiur_fn_254( }) } -const INPUT_SIZE_255: usize = 2; -const IN_255: usize = 2; -const OUT_255: usize = 34; -fn aiur_fn_255( - inp: [G; IN_255], +const INPUT_SIZE_277: usize = 2; +const IN_277: usize = 2; +const OUT_277: usize = 34; +fn aiur_fn_277( + inp: [G; IN_277], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_255], ExecError> { +) -> Result<[G; OUT_277], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24689,14 +26290,14 @@ fn aiur_fn_255( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_255] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_277] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_38: G = G::from_u64(1); let __v_39: G = (__v_1 - __v_38); - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_37, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; let __v_42: G = __r_arr[2]; @@ -24731,8 +26332,8 @@ fn aiur_fn_255( let __v_71: G = __r_arr[31]; let __v_72: G = __r_arr[32]; let __v_73: G = __r_arr[33]; - let __ret: [G; OUT_255] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; - if let Some(result) = record.function_queries[255].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_277] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; + if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24744,15 +26345,15 @@ fn aiur_fn_255( }) } -const INPUT_SIZE_256: usize = 33; -const IN_256: usize = 33; -const OUT_256: usize = 12; -fn aiur_fn_256( - inp: [G; IN_256], +const INPUT_SIZE_278: usize = 33; +const IN_278: usize = 33; +const OUT_278: usize = 12; +fn aiur_fn_278( + inp: [G; IN_278], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_256], ExecError> { +) -> Result<[G; OUT_278], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24789,7 +26390,7 @@ fn aiur_fn_256( let __v_32: G = inp[32]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = G::from_u64(5); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; @@ -24798,26 +26399,26 @@ fn aiur_fn_256( let __v_36: G = __r_arr[0]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_254(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = G::from_u64(0); - let __ret: [G; OUT_256] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; - if let Some(result) = record.function_queries[256].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_278] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39]; + if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_257: usize = 40; -const IN_257: usize = 40; -const OUT_257: usize = 12; -fn aiur_fn_257( - inp: [G; IN_257], +const INPUT_SIZE_279: usize = 40; +const IN_279: usize = 40; +const OUT_279: usize = 12; +fn aiur_fn_279( + inp: [G; IN_279], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_257], ExecError> { +) -> Result<[G; OUT_279], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24861,7 +26462,7 @@ fn aiur_fn_257( let __v_39: G = inp[39]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(6); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; @@ -24873,23 +26474,23 @@ fn aiur_fn_257( let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_257] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; - if let Some(result) = record.function_queries[257].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_279] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; + if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_258: usize = 6; -const IN_258: usize = 6; -const OUT_258: usize = 1; -fn aiur_fn_258( - inp: [G; IN_258], +const INPUT_SIZE_280: usize = 6; +const IN_280: usize = 6; +const OUT_280: usize = 1; +fn aiur_fn_280( + inp: [G; IN_280], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_258], ExecError> { +) -> Result<[G; OUT_280], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -24914,25 +26515,25 @@ fn aiur_fn_258( let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 5] = [__v_17, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_258] = [__v_19]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_280] = [__v_19]; + if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 5] = [__v_18, __v_5, __v_19, __v_17, __v_22]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_258] = [__v_23]; - if let Some(result) = record.function_queries[258].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_280] = [__v_23]; + if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -24944,15 +26545,15 @@ fn aiur_fn_258( }) } -const INPUT_SIZE_259: usize = 50; -const IN_259: usize = 50; -const OUT_259: usize = 12; -fn aiur_fn_259( - inp: [G; IN_259], +const INPUT_SIZE_281: usize = 50; +const IN_281: usize = 50; +const OUT_281: usize = 12; +fn aiur_fn_281( + inp: [G; IN_281], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_259], ExecError> { +) -> Result<[G; OUT_281], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25006,10 +26607,10 @@ fn aiur_fn_259( let __v_49: G = inp[49]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_250(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_250] = unsafe { *(result.output.as_ptr() as *const [G; OUT_250]) }; __ret } } else { aiur_fn_250(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_258(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(7); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; @@ -25022,23 +26623,23 @@ fn aiur_fn_259( let __v_57: G = __r_arr[0]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __ret: [G; OUT_259] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; - if let Some(result) = record.function_queries[259].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_281] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45]; + if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_260: usize = 1; -const IN_260: usize = 1; -const OUT_260: usize = 48; -fn aiur_fn_260( - inp: [G; IN_260], +const INPUT_SIZE_282: usize = 1; +const IN_282: usize = 1; +const OUT_282: usize = 48; +fn aiur_fn_282( + inp: [G; IN_282], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_260], ExecError> { +) -> Result<[G; OUT_282], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -25147,21 +26748,21 @@ fn aiur_fn_260( if (__v_89 != __v_91) { return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) }); } - let __ret: [G; OUT_260] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; - if let Some(result) = record.function_queries[260].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_282] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; + if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_261: usize = 1; -const IN_261: usize = 1; -const OUT_261: usize = 1; -fn aiur_fn_261( - inp: [G; IN_261], +const INPUT_SIZE_283: usize = 1; +const IN_283: usize = 1; +const OUT_283: usize = 1; +fn aiur_fn_283( + inp: [G; IN_283], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_261], ExecError> { +) -> Result<[G; OUT_283], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -25210,8 +26811,8 @@ fn aiur_fn_261( let __v_40: G = __loaded[2]; match __v_38.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_261] = [__v_39]; - if let Some(result) = record.function_queries[261].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_283] = [__v_39]; + if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25221,15 +26822,15 @@ fn aiur_fn_261( }) } -const INPUT_SIZE_262: usize = 1; -const IN_262: usize = 1; -const OUT_262: usize = 1; -fn aiur_fn_262( - inp: [G; IN_262], +const INPUT_SIZE_284: usize = 1; +const IN_284: usize = 1; +const OUT_284: usize = 1; +fn aiur_fn_284( + inp: [G; IN_284], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_262], ExecError> { +) -> Result<[G; OUT_284], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -25273,43 +26874,43 @@ fn aiur_fn_262( let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[2].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_2(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_20(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_262] = [__v_37]; - if let Some(result) = record.function_queries[262].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_284] = [__v_37]; + if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_263: usize = 2; -const IN_263: usize = 2; -const OUT_263: usize = 1; -fn aiur_fn_263( - inp: [G; IN_263], +const INPUT_SIZE_285: usize = 2; +const IN_285: usize = 2; +const OUT_285: usize = 1; +fn aiur_fn_285( + inp: [G; IN_285], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_263], ExecError> { +) -> Result<[G; OUT_285], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 2u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_263] = [__v_2]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_2]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_263] = [__v_2]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_2]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_263] = [__v_2]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_2]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25318,14 +26919,14 @@ fn aiur_fn_263( match __v_1.as_canonical_u64() { 1u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_263] = [__v_2]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_2]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_263] = [__v_2]; - if let Some(result) = record.function_queries[263].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_285] = [__v_2]; + if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25337,15 +26938,15 @@ fn aiur_fn_263( }) } -const INPUT_SIZE_264: usize = 14; -const IN_264: usize = 14; -const OUT_264: usize = 1; -fn aiur_fn_264( - inp: [G; IN_264], +const INPUT_SIZE_286: usize = 14; +const IN_286: usize = 14; +const OUT_286: usize = 1; +fn aiur_fn_286( + inp: [G; IN_286], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_264], ExecError> { +) -> Result<[G; OUT_286], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25363,22 +26964,22 @@ fn aiur_fn_264( let __v_13: G = inp[13]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 0u64 => { let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_264] = [__v_17]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_286] = [__v_17]; + if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_264] = [__v_15]; - if let Some(result) = record.function_queries[264].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_286] = [__v_15]; + if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25387,18 +26988,18 @@ fn aiur_fn_264( }) } -const INPUT_SIZE_265: usize = 1; -const IN_265: usize = 1; -const OUT_265: usize = 1; -fn aiur_fn_265( - inp: [G; IN_265], +const INPUT_SIZE_287: usize = 1; +const IN_287: usize = 1; +const OUT_287: usize = 1; +fn aiur_fn_287( + inp: [G; IN_287], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_265], ExecError> { +) -> Result<[G; OUT_287], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -25451,11 +27052,11 @@ fn aiur_fn_265( _ => { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_263(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; match __v_50.as_canonical_u64() { 0u64 => { @@ -25477,7 +27078,7 @@ fn aiur_fn_265( } }; let __v_50: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -25491,15 +27092,15 @@ fn aiur_fn_265( let __v_61: G = __r_arr[10]; let __v_62: G = __r_arr[11]; let __v_63: G = { let __values: [G; 12] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_265] = [__v_63]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_63]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_252(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_252] = unsafe { *(result.output.as_ptr() as *const [G; OUT_252]) }; __ret } } else { aiur_fn_252(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -25513,15 +27114,15 @@ fn aiur_fn_265( let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_265] = [__v_64]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_64]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_46, __v_47, __v_51, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -25535,17 +27136,17 @@ fn aiur_fn_265( let __v_62: G = __r_arr[10]; let __v_63: G = __r_arr[11]; let __v_64: G = { let __values: [G; 12] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_265] = [__v_64]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_64]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_266(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_266] = unsafe { *(result.output.as_ptr() as *const [G; OUT_266]) }; __ret } } else { aiur_fn_266(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_265] = [__v_49]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_49]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25555,10 +27156,10 @@ fn aiur_fn_265( _ => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_265] = [__v_50]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_50]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25570,10 +27171,10 @@ fn aiur_fn_265( let __v_49: G = __r_arr[0]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_265] = [__v_51]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_51]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25583,10 +27184,10 @@ fn aiur_fn_265( _ => { let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_269(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_10, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_265] = [__v_50]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_50]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -25598,7 +27199,7 @@ fn aiur_fn_265( let __v_52: G = { let __values: [G; 3] = [__v_50, __v_51, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_53: G = { let __values: [G; 3] = [__v_49, __v_0, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_0, __v_54, __v_46, __v_47, __v_53, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -25612,8 +27213,8 @@ fn aiur_fn_265( let __v_65: G = __r_arr[10]; let __v_66: G = __r_arr[11]; let __v_67: G = { let __values: [G; 12] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_265] = [__v_67]; - if let Some(result) = record.function_queries[265].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_287] = [__v_67]; + if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25625,15 +27226,15 @@ fn aiur_fn_265( }) } -const INPUT_SIZE_266: usize = 10; -const IN_266: usize = 10; -const OUT_266: usize = 1; -fn aiur_fn_266( - inp: [G; IN_266], +const INPUT_SIZE_288: usize = 10; +const IN_288: usize = 10; +const OUT_288: usize = 1; +fn aiur_fn_288( + inp: [G; IN_288], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_266], ExecError> { +) -> Result<[G; OUT_288], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -25645,7 +27246,7 @@ fn aiur_fn_266( let __v_7: G = inp[7]; let __v_8: G = inp[8]; let __v_9: G = inp[9]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -25698,7 +27299,7 @@ fn aiur_fn_266( _ => { match __v_10.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; let __v_60: G = __r_arr[2]; @@ -25746,11 +27347,11 @@ fn aiur_fn_266( let __v_102: G = __r_arr[44]; match __v_58.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_261(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; let __v_103: G = __r_arr[0]; - let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; - let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_251(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_251] = unsafe { *(result.output.as_ptr() as *const [G; OUT_251]) }; __ret } } else { aiur_fn_251(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; let __v_105: G = __r_arr[0]; let __v_106: G = __r_arr[1]; let __v_107: G = __r_arr[2]; @@ -25764,8 +27365,8 @@ fn aiur_fn_266( let __v_115: G = __r_arr[10]; let __v_116: G = __r_arr[11]; let __v_117: G = { let __values: [G; 12] = [__v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_266] = [__v_117]; - if let Some(result) = record.function_queries[266].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_288] = [__v_117]; + if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25782,19 +27383,19 @@ fn aiur_fn_266( }) } -const INPUT_SIZE_267: usize = 2; -const IN_267: usize = 2; -const OUT_267: usize = 1; -fn aiur_fn_267( - inp: [G; IN_267], +const INPUT_SIZE_289: usize = 2; +const IN_289: usize = 2; +const OUT_289: usize = 1; +fn aiur_fn_289( + inp: [G; IN_289], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_267], ExecError> { +) -> Result<[G; OUT_289], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -25847,7 +27448,7 @@ fn aiur_fn_267( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -25895,9 +27496,9 @@ fn aiur_fn_267( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_256(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -25911,8 +27512,8 @@ fn aiur_fn_267( let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_267] = [__v_108]; - if let Some(result) = record.function_queries[267].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_289] = [__v_108]; + if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -25929,20 +27530,20 @@ fn aiur_fn_267( }) } -const INPUT_SIZE_268: usize = 3; -const IN_268: usize = 3; -const OUT_268: usize = 1; -fn aiur_fn_268( - inp: [G; IN_268], +const INPUT_SIZE_290: usize = 3; +const IN_290: usize = 3; +const OUT_290: usize = 1; +fn aiur_fn_290( + inp: [G; IN_290], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_268], ExecError> { +) -> Result<[G; OUT_290], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -25995,7 +27596,7 @@ fn aiur_fn_268( _ => { match __v_3.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -26045,7 +27646,7 @@ fn aiur_fn_268( 1u64 => { match __v_52.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_78, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -26080,9 +27681,9 @@ fn aiur_fn_268( let __v_127: G = __r_arr[31]; let __v_128: G = __r_arr[32]; let __v_129: G = __r_arr[33]; - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_130: G = __r_arr[0]; - let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_257(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_257] = unsafe { *(result.output.as_ptr() as *const [G; OUT_257]) }; __ret } } else { aiur_fn_257(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; let __v_131: G = __r_arr[0]; let __v_132: G = __r_arr[1]; let __v_133: G = __r_arr[2]; @@ -26096,8 +27697,8 @@ fn aiur_fn_268( let __v_141: G = __r_arr[10]; let __v_142: G = __r_arr[11]; let __v_143: G = { let __values: [G; 12] = [__v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_268] = [__v_143]; - if let Some(result) = record.function_queries[268].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_290] = [__v_143]; + if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26116,19 +27717,19 @@ fn aiur_fn_268( }) } -const INPUT_SIZE_269: usize = 2; -const IN_269: usize = 2; -const OUT_269: usize = 1; -fn aiur_fn_269( - inp: [G; IN_269], +const INPUT_SIZE_291: usize = 2; +const IN_291: usize = 2; +const OUT_291: usize = 1; +fn aiur_fn_291( + inp: [G; IN_291], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_269], ExecError> { +) -> Result<[G; OUT_291], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -26181,7 +27782,7 @@ fn aiur_fn_269( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -26229,9 +27830,9 @@ fn aiur_fn_269( let __v_94: G = __r_arr[44]; match __v_50.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_95: G = __r_arr[0]; - let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -26245,8 +27846,8 @@ fn aiur_fn_269( let __v_106: G = __r_arr[10]; let __v_107: G = __r_arr[11]; let __v_108: G = { let __values: [G; 12] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_269] = [__v_108]; - if let Some(result) = record.function_queries[269].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_291] = [__v_108]; + if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26263,15 +27864,15 @@ fn aiur_fn_269( }) } -const INPUT_SIZE_270: usize = 2; -const IN_270: usize = 2; -const OUT_270: usize = 45; -fn aiur_fn_270( - inp: [G; IN_270], +const INPUT_SIZE_292: usize = 2; +const IN_292: usize = 2; +const OUT_292: usize = 45; +fn aiur_fn_292( + inp: [G; IN_292], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_270], ExecError> { +) -> Result<[G; OUT_292], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26327,14 +27928,14 @@ fn aiur_fn_270( 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_270] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_292] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; + if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 - __v_49); - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -26380,8 +27981,8 @@ fn aiur_fn_270( let __v_93: G = __r_arr[42]; let __v_94: G = __r_arr[43]; let __v_95: G = __r_arr[44]; - let __ret: [G; OUT_270] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; - if let Some(result) = record.function_queries[270].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_292] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95]; + if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26393,15 +27994,15 @@ fn aiur_fn_270( }) } -const INPUT_SIZE_271: usize = 1; -const IN_271: usize = 1; -const OUT_271: usize = 8; -fn aiur_fn_271( - inp: [G; IN_271], +const INPUT_SIZE_293: usize = 1; +const IN_293: usize = 1; +const OUT_293: usize = 8; +fn aiur_fn_293( + inp: [G; IN_293], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_271], ExecError> { +) -> Result<[G; OUT_293], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes(); @@ -26422,26 +28023,26 @@ fn aiur_fn_271( if (__v_9 != __v_0) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) }); } - let __ret: [G; OUT_271] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; - if let Some(result) = record.function_queries[271].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_293] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_272: usize = 3; -const IN_272: usize = 3; -const OUT_272: usize = 1; -fn aiur_fn_272( - inp: [G; IN_272], +const INPUT_SIZE_294: usize = 3; +const IN_294: usize = 3; +const OUT_294: usize = 1; +fn aiur_fn_294( + inp: [G; IN_294], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_272], ExecError> { +) -> Result<[G; OUT_294], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_270(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -26487,7 +28088,7 @@ fn aiur_fn_272( let __v_45: G = __r_arr[42]; let __v_46: G = __r_arr[43]; let __v_47: G = __r_arr[44]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -26578,42 +28179,42 @@ fn aiur_fn_272( let __v_113: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; - let __ret: [G; OUT_272] = [__v_114]; - if let Some(result) = record.function_queries[272].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_294] = [__v_114]; + if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_273: usize = 2; -const IN_273: usize = 2; -const OUT_273: usize = 1; -fn aiur_fn_273( - inp: [G; IN_273], +const INPUT_SIZE_295: usize = 2; +const IN_295: usize = 2; +const OUT_295: usize = 1; +fn aiur_fn_295( + inp: [G; IN_295], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_273], ExecError> { +) -> Result<[G; OUT_295], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_273] = [__v_3]; - if let Some(result) = record.function_queries[273].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_295] = [__v_3]; + if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_274: usize = 4; -const IN_274: usize = 4; -const OUT_274: usize = 1; -fn aiur_fn_274( - inp: [G; IN_274], +const INPUT_SIZE_296: usize = 4; +const IN_296: usize = 4; +const OUT_296: usize = 1; +fn aiur_fn_296( + inp: [G; IN_296], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_274], ExecError> { +) -> Result<[G; OUT_296], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26672,21 +28273,21 @@ fn aiur_fn_274( 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_274] = [__v_53]; - if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_53]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(1); let __v_54: G = (__v_3 + __v_53); - let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_274(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = { let __values: [G; 3] = [__v_51, __v_52, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_274] = [__v_56]; - if let Some(result) = record.function_queries[274].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_296] = [__v_56]; + if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26696,15 +28297,15 @@ fn aiur_fn_274( }) } -const INPUT_SIZE_275: usize = 1; -const IN_275: usize = 1; -const OUT_275: usize = 1; -fn aiur_fn_275( - inp: [G; IN_275], +const INPUT_SIZE_297: usize = 1; +const IN_297: usize = 1; +const OUT_297: usize = 1; +fn aiur_fn_297( + inp: [G; IN_297], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_275], ExecError> { +) -> Result<[G; OUT_297], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -26714,57 +28315,57 @@ fn aiur_fn_275( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_275] = [__v_4]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_4]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_275] = [__v_4]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_4]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_275] = [__v_4]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_4]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_275] = [__v_6]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_6]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_275] = [__v_6]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_6]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_275] = [__v_6]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_6]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 3u64 => { - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_275] = [__v_4]; - if let Some(result) = record.function_queries[275].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_297] = [__v_4]; + if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26774,15 +28375,15 @@ fn aiur_fn_275( }) } -const INPUT_SIZE_276: usize = 2; -const IN_276: usize = 2; -const OUT_276: usize = 1; -fn aiur_fn_276( - inp: [G; IN_276], +const INPUT_SIZE_298: usize = 2; +const IN_298: usize = 2; +const OUT_298: usize = 1; +fn aiur_fn_298( + inp: [G; IN_298], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_276], ExecError> { +) -> Result<[G; OUT_298], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26799,14 +28400,14 @@ fn aiur_fn_276( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_276] = [__v_8]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_276] = [__v_8]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26818,16 +28419,16 @@ fn aiur_fn_276( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_276] = [__v_8]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_276] = [__v_8]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26839,19 +28440,19 @@ fn aiur_fn_276( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_276] = [__v_10]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_10]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_276] = [__v_8]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26863,19 +28464,19 @@ fn aiur_fn_276( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 * __v_9); - let __ret: [G; OUT_276] = [__v_10]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_10]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_276] = [__v_8]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26889,14 +28490,14 @@ fn aiur_fn_276( 4u64 => { let __v_8: G = (__v_3 - __v_6); let __v_9: G = G::from_bool((__v_8 == G::ZERO)); - let __ret: [G; OUT_276] = [__v_9]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_9]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_276] = [__v_8]; - if let Some(result) = record.function_queries[276].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_298] = [__v_8]; + if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -26908,15 +28509,15 @@ fn aiur_fn_276( }) } -const INPUT_SIZE_277: usize = 2; -const IN_277: usize = 2; -const OUT_277: usize = 1; -fn aiur_fn_277( - inp: [G; IN_277], +const INPUT_SIZE_299: usize = 2; +const IN_299: usize = 2; +const OUT_299: usize = 1; +fn aiur_fn_299( + inp: [G; IN_299], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_277], ExecError> { +) -> Result<[G; OUT_299], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -26933,14 +28534,14 @@ fn aiur_fn_277( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_277] = [__v_8]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_8]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_277] = [__v_8]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_8]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -26956,8 +28557,8 @@ fn aiur_fn_277( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_277] = [__v_8]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_8]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -26965,8 +28566,8 @@ fn aiur_fn_277( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_277] = [__v_9]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_9]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -26974,15 +28575,15 @@ fn aiur_fn_277( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(2); - let __ret: [G; OUT_277] = [__v_10]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_10]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_277] = [__v_10]; - if let Some(result) = record.function_queries[277].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_299] = [__v_10]; + if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27007,15 +28608,15 @@ fn aiur_fn_277( }) } -const INPUT_SIZE_278: usize = 2; -const IN_278: usize = 2; -const OUT_278: usize = 1; -fn aiur_fn_278( - inp: [G; IN_278], +const INPUT_SIZE_300: usize = 2; +const IN_300: usize = 2; +const OUT_300: usize = 1; +fn aiur_fn_300( + inp: [G; IN_300], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_278], ExecError> { +) -> Result<[G; OUT_300], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27026,8 +28627,8 @@ fn aiur_fn_278( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_278] = [__v_5]; - if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_5]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27038,8 +28639,8 @@ fn aiur_fn_278( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_278] = [__v_8]; - if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_8]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27047,25 +28648,25 @@ fn aiur_fn_278( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_278] = [__v_9]; - if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_9]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_278] = [__v_10]; - if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_10]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_278] = [__v_10]; - if let Some(result) = record.function_queries[278].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_300] = [__v_10]; + if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27090,15 +28691,15 @@ fn aiur_fn_278( }) } -const INPUT_SIZE_279: usize = 2; -const IN_279: usize = 2; -const OUT_279: usize = 1; -fn aiur_fn_279( - inp: [G; IN_279], +const INPUT_SIZE_301: usize = 2; +const IN_301: usize = 2; +const OUT_301: usize = 1; +fn aiur_fn_301( + inp: [G; IN_301], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_279], ExecError> { +) -> Result<[G; OUT_301], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27115,14 +28716,14 @@ fn aiur_fn_279( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_279] = [__v_8]; - if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_279] = [__v_8]; - if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27138,15 +28739,15 @@ fn aiur_fn_279( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_279] = [__v_8]; - if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_279] = [__v_8]; - if let Some(result) = record.function_queries[279].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_301] = [__v_8]; + if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27161,15 +28762,15 @@ fn aiur_fn_279( }) } -const INPUT_SIZE_280: usize = 2; -const IN_280: usize = 2; -const OUT_280: usize = 2; -fn aiur_fn_280( - inp: [G; IN_280], +const INPUT_SIZE_302: usize = 2; +const IN_302: usize = 2; +const OUT_302: usize = 2; +fn aiur_fn_302( + inp: [G; IN_302], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_280], ExecError> { +) -> Result<[G; OUT_302], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27185,8 +28786,8 @@ fn aiur_fn_280( 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_280] = [__v_5, __v_10]; - if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_5, __v_10]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27196,8 +28797,8 @@ fn aiur_fn_280( 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_280] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27205,18 +28806,18 @@ fn aiur_fn_280( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_280] = [__v_7, __v_1]; - if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_7, __v_1]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_280] = [__v_7, __v_10]; - if let Some(result) = record.function_queries[280].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_302] = [__v_7, __v_10]; + if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27236,15 +28837,15 @@ fn aiur_fn_280( }) } -const INPUT_SIZE_281: usize = 3; -const IN_281: usize = 3; -const OUT_281: usize = 1; -fn aiur_fn_281( - inp: [G; IN_281], +const INPUT_SIZE_303: usize = 3; +const IN_303: usize = 3; +const OUT_303: usize = 1; +fn aiur_fn_303( + inp: [G; IN_303], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_281], ExecError> { +) -> Result<[G; OUT_303], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27261,8 +28862,8 @@ fn aiur_fn_281( 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_281] = [__v_11]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_11]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27277,8 +28878,8 @@ fn aiur_fn_281( 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_281] = [__v_11]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_11]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27286,11 +28887,11 @@ fn aiur_fn_281( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_281] = [__v_12]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_12]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27300,13 +28901,13 @@ fn aiur_fn_281( 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_281] = [__v_13]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_13]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_281] = [__v_0]; - if let Some(result) = record.function_queries[281].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_303] = [__v_0]; + if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27333,15 +28934,15 @@ fn aiur_fn_281( }) } -const INPUT_SIZE_282: usize = 2; -const IN_282: usize = 2; -const OUT_282: usize = 1; -fn aiur_fn_282( - inp: [G; IN_282], +const INPUT_SIZE_304: usize = 2; +const IN_304: usize = 2; +const OUT_304: usize = 1; +fn aiur_fn_304( + inp: [G; IN_304], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_282], ExecError> { +) -> Result<[G; OUT_304], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27358,14 +28959,14 @@ fn aiur_fn_282( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_282] = [__v_8]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_8]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_282] = [__v_8]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_8]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27381,8 +28982,8 @@ fn aiur_fn_282( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_282] = [__v_8]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_8]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27402,24 +29003,24 @@ fn aiur_fn_282( let __v_13: G = (__v_9 - __v_11); match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_282] = [__v_14]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_14]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_282] = [__v_14]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_14]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_282] = [__v_13]; - if let Some(result) = record.function_queries[282].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_304] = [__v_13]; + if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27440,15 +29041,15 @@ fn aiur_fn_282( }) } -const INPUT_SIZE_283: usize = 1; -const IN_283: usize = 1; -const OUT_283: usize = 1; -fn aiur_fn_283( - inp: [G; IN_283], +const INPUT_SIZE_305: usize = 1; +const IN_305: usize = 1; +const OUT_305: usize = 1; +fn aiur_fn_305( + inp: [G; IN_305], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_283], ExecError> { +) -> Result<[G; OUT_305], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -27458,8 +29059,8 @@ fn aiur_fn_283( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_283] = [__v_4]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_4]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27468,18 +29069,18 @@ fn aiur_fn_283( let __v_5: G = __loaded[1]; match __v_4.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_283] = [__v_5]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_5]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_283] = [__v_6]; - if let Some(result) = record.function_queries[283].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_305] = [__v_6]; + if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27496,15 +29097,15 @@ fn aiur_fn_283( }) } -const INPUT_SIZE_284: usize = 2; -const IN_284: usize = 2; -const OUT_284: usize = 1; -fn aiur_fn_284( - inp: [G; IN_284], +const INPUT_SIZE_306: usize = 2; +const IN_306: usize = 2; +const OUT_306: usize = 1; +fn aiur_fn_306( + inp: [G; IN_306], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_284], ExecError> { +) -> Result<[G; OUT_306], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27514,8 +29115,8 @@ fn aiur_fn_284( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_284] = [__v_0]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_0]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27525,8 +29126,8 @@ fn aiur_fn_284( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_284] = [__v_0]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_0]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27544,21 +29145,21 @@ fn aiur_fn_284( match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_13, __v_3, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_284] = [__v_15]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_15]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_284] = [__v_14]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_14]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27566,18 +29167,18 @@ fn aiur_fn_284( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = { let __values: [G; 3] = [__v_15, __v_3, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_284] = [__v_17]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_17]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_284] = [__v_15]; - if let Some(result) = record.function_queries[284].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_306] = [__v_15]; + if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27611,23 +29212,23 @@ fn aiur_fn_284( }) } -const INPUT_SIZE_285: usize = 3; -const IN_285: usize = 3; -const OUT_285: usize = 1; -fn aiur_fn_285( - inp: [G; IN_285], +const INPUT_SIZE_307: usize = 3; +const IN_307: usize = 3; +const OUT_307: usize = 1; +fn aiur_fn_307( + inp: [G; IN_307], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_285], ExecError> { +) -> Result<[G; OUT_307], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_285] = [__v_0]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_0]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -27637,15 +29238,15 @@ fn aiur_fn_285( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_285] = [__v_6]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_6]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_285] = [__v_0]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_0]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27654,25 +29255,25 @@ fn aiur_fn_285( } }, _ => { - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_285] = [__v_3]; - if let Some(result) = record.function_queries[285].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_307] = [__v_3]; + if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_286: usize = 3; -const IN_286: usize = 3; -const OUT_286: usize = 1; -fn aiur_fn_286( - inp: [G; IN_286], +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_286], ExecError> { +) -> Result<[G; OUT_308], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27692,8 +29293,8 @@ fn aiur_fn_286( 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_286] = [__v_14]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_14]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27703,7 +29304,7 @@ fn aiur_fn_286( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { @@ -27713,13 +29314,13 @@ fn aiur_fn_286( 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_286] = [__v_13]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_13]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_286] = [__v_0]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_0]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -27734,17 +29335,17 @@ fn aiur_fn_286( 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_286] = [__v_15]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_15]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_286(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_286] = [__v_12]; - if let Some(result) = record.function_queries[286].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_308] = [__v_12]; + if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27758,15 +29359,15 @@ fn aiur_fn_286( }) } -const INPUT_SIZE_287: usize = 4; -const IN_287: usize = 4; -const OUT_287: usize = 1; -fn aiur_fn_287( - inp: [G; IN_287], +const INPUT_SIZE_309: usize = 4; +const IN_309: usize = 4; +const OUT_309: usize = 1; +fn aiur_fn_309( + inp: [G; IN_309], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_287], ExecError> { +) -> Result<[G; OUT_309], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27791,8 +29392,8 @@ fn aiur_fn_287( 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_287] = [__v_19]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_19]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -27802,17 +29403,17 @@ fn aiur_fn_287( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_281(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_281] = unsafe { *(result.output.as_ptr() as *const [G; OUT_281]) }; __ret } } else { aiur_fn_281(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_7, __v_8, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_11, __v_13, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_14]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_14]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -27826,17 +29427,17 @@ fn aiur_fn_287( 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_287] = [__v_20]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_20]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 3] = [__v_11, __v_5, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_287] = [__v_13]; - if let Some(result) = record.function_queries[287].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_309] = [__v_13]; + if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27850,15 +29451,15 @@ fn aiur_fn_287( }) } -const INPUT_SIZE_288: usize = 4; -const IN_288: usize = 4; -const OUT_288: usize = 1; -fn aiur_fn_288( - inp: [G; IN_288], +const INPUT_SIZE_310: usize = 4; +const IN_310: usize = 4; +const OUT_310: usize = 1; +fn aiur_fn_310( + inp: [G; IN_310], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_288], ExecError> { +) -> Result<[G; OUT_310], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27870,63 +29471,63 @@ fn aiur_fn_288( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_288] = [__v_7]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_7]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_288] = [__v_9]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_9]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_288] = [__v_8]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_8]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_288] = [__v_7]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_7]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_288] = [__v_10]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_10]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_288] = [__v_3]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_3]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_288] = [__v_9]; - if let Some(result) = record.function_queries[288].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_310] = [__v_9]; + if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -27943,15 +29544,15 @@ fn aiur_fn_288( }) } -const INPUT_SIZE_289: usize = 5; -const IN_289: usize = 5; -const OUT_289: usize = 1; -fn aiur_fn_289( - inp: [G; IN_289], +const INPUT_SIZE_311: usize = 5; +const IN_311: usize = 5; +const OUT_311: usize = 1; +fn aiur_fn_311( + inp: [G; IN_311], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_289], ExecError> { +) -> Result<[G; OUT_311], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -27964,55 +29565,55 @@ fn aiur_fn_289( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_289] = [__v_8]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_8]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_3 + __v_8); - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_289] = [__v_11]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_11]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_289] = [__v_9]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_9]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_289] = [__v_9]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_9]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_280(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_285(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_285] = unsafe { *(result.output.as_ptr() as *const [G; OUT_285]) }; __ret } } else { aiur_fn_285(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_289] = [__v_12]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_12]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28021,17 +29622,17 @@ fn aiur_fn_289( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; break '__mc_0 [__v_10]; }, } }; let __v_10: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_289] = [__v_11]; - if let Some(result) = record.function_queries[289].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_311] = [__v_11]; + if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28046,15 +29647,15 @@ fn aiur_fn_289( }) } -const INPUT_SIZE_290: usize = 2; -const IN_290: usize = 2; -const OUT_290: usize = 1; -fn aiur_fn_290( - inp: [G; IN_290], +const INPUT_SIZE_312: usize = 2; +const IN_312: usize = 2; +const OUT_312: usize = 1; +fn aiur_fn_312( + inp: [G; IN_312], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_290], ExecError> { +) -> Result<[G; OUT_312], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28064,19 +29665,19 @@ fn aiur_fn_290( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_290] = [__v_0]; - if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_0]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_290] = [__v_8]; - if let Some(result) = record.function_queries[290].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_312] = [__v_8]; + if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28086,15 +29687,15 @@ fn aiur_fn_290( }) } -const INPUT_SIZE_291: usize = 2; -const IN_291: usize = 2; -const OUT_291: usize = 1; -fn aiur_fn_291( - inp: [G; IN_291], +const INPUT_SIZE_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_291], ExecError> { +) -> Result<[G; OUT_313], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28104,8 +29705,8 @@ fn aiur_fn_291( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_291] = [__v_0]; - if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_0]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28121,18 +29722,18 @@ fn aiur_fn_291( let __v_10: G = __loaded[2]; match __v_8.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_291] = [__v_12]; - if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_12]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_279(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { 0u64 => { @@ -28165,7 +29766,7 @@ fn aiur_fn_291( break '__mc_2 [__v_17]; }, 0u64 => { - let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_283(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = (__v_17 + __v_18); @@ -28206,7 +29807,7 @@ fn aiur_fn_291( break '__mc_3 [__v_7]; }, 0u64 => { - let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_284(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_3 [__v_17]; }, @@ -28222,10 +29823,10 @@ fn aiur_fn_291( }; 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_291] = { let __args: [G; IN_291] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_291(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_291] = [__v_16]; - if let Some(result) = record.function_queries[291].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_313] = [__v_16]; + if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28241,15 +29842,15 @@ fn aiur_fn_291( }) } -const INPUT_SIZE_292: usize = 1; -const IN_292: usize = 1; -const OUT_292: usize = 1; -fn aiur_fn_292( - inp: [G; IN_292], +const INPUT_SIZE_314: usize = 1; +const IN_314: usize = 1; +const OUT_314: usize = 1; +fn aiur_fn_314( + inp: [G; IN_314], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_292], ExecError> { +) -> Result<[G; OUT_314], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -28258,8 +29859,8 @@ fn aiur_fn_292( let __v_3: G = __loaded[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_292] = [__v_0]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_0]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28277,15 +29878,15 @@ fn aiur_fn_292( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_292] = [__v_10]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_10]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_292] = [__v_0]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_0]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28294,8 +29895,8 @@ fn aiur_fn_292( } }, _ => { - let __ret: [G; OUT_292] = [__v_0]; - if let Some(result) = record.function_queries[292].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_314] = [__v_0]; + if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28309,21 +29910,21 @@ fn aiur_fn_292( }) } -const INPUT_SIZE_293: usize = 2; -const IN_293: usize = 2; -const OUT_293: usize = 1; -fn aiur_fn_293( - inp: [G; IN_293], +const INPUT_SIZE_315: usize = 2; +const IN_315: usize = 2; +const OUT_315: usize = 1; +fn aiur_fn_315( + inp: [G; IN_315], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_293], ExecError> { +) -> Result<[G; OUT_315], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_292(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -28338,14 +29939,14 @@ fn aiur_fn_293( match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_293] = [__v_10]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_10]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_293] = [__v_10]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_10]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28361,8 +29962,8 @@ fn aiur_fn_293( match __v_7.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_293] = [__v_10]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_10]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28378,27 +29979,27 @@ fn aiur_fn_293( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_277(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = (__v_11 - __v_14); match __v_17.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_293] = [__v_19]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_19]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_293] = [__v_19]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_19]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28408,16 +30009,16 @@ fn aiur_fn_293( }, _ => { let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_293] = [__v_18]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_18]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_293] = [__v_17]; - if let Some(result) = record.function_queries[293].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_315] = [__v_17]; + if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28438,15 +30039,15 @@ fn aiur_fn_293( }) } -const INPUT_SIZE_294: usize = 3; -const IN_294: usize = 3; -const OUT_294: usize = 1; -fn aiur_fn_294( - inp: [G; IN_294], +const INPUT_SIZE_316: usize = 3; +const IN_316: usize = 3; +const OUT_316: usize = 1; +fn aiur_fn_316( + inp: [G; IN_316], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_294], ExecError> { +) -> Result<[G; OUT_316], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28458,8 +30059,8 @@ fn aiur_fn_294( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_294] = [__v_6]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_6]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28469,14 +30070,14 @@ fn aiur_fn_294( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_294] = [__v_10]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_10]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28487,7 +30088,7 @@ fn aiur_fn_294( break '__mc_0 [__v_11]; }, 1u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; break '__mc_0 [__v_11]; }, @@ -28500,15 +30101,15 @@ fn aiur_fn_294( match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_294] = [__v_12]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_12]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_294] = [__v_12]; - if let Some(result) = record.function_queries[294].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_316] = [__v_12]; + if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28527,15 +30128,15 @@ fn aiur_fn_294( }) } -const INPUT_SIZE_295: usize = 2; -const IN_295: usize = 2; -const OUT_295: usize = 1; -fn aiur_fn_295( - inp: [G; IN_295], +const INPUT_SIZE_317: usize = 2; +const IN_317: usize = 2; +const OUT_317: usize = 1; +fn aiur_fn_317( + inp: [G; IN_317], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_295], ExecError> { +) -> Result<[G; OUT_317], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28546,8 +30147,8 @@ fn aiur_fn_295( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_295] = [__v_5]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_5]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28562,15 +30163,15 @@ fn aiur_fn_295( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_295] = [__v_10]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_10]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_295] = [__v_10]; - if let Some(result) = record.function_queries[295].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_317] = [__v_10]; + if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28587,15 +30188,15 @@ fn aiur_fn_295( }) } -const INPUT_SIZE_296: usize = 4; -const IN_296: usize = 4; -const OUT_296: usize = 1; -fn aiur_fn_296( - inp: [G; IN_296], +const INPUT_SIZE_318: usize = 4; +const IN_318: usize = 4; +const OUT_318: usize = 1; +fn aiur_fn_318( + inp: [G; IN_318], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_296], ExecError> { +) -> Result<[G; OUT_318], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28608,8 +30209,8 @@ fn aiur_fn_296( match __v_4.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_296] = [__v_7]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_7]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28619,31 +30220,31 @@ fn aiur_fn_296( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_278(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_296] = [__v_11]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_11]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_296] = [__v_12]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_12]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_296] = [__v_12]; - if let Some(result) = record.function_queries[296].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_318] = [__v_12]; + if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28662,15 +30263,15 @@ fn aiur_fn_296( }) } -const INPUT_SIZE_297: usize = 3; -const IN_297: usize = 3; -const OUT_297: usize = 1; -fn aiur_fn_297( - inp: [G; IN_297], +const INPUT_SIZE_319: usize = 3; +const IN_319: usize = 3; +const OUT_319: usize = 1; +fn aiur_fn_319( + inp: [G; IN_319], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_297], ExecError> { +) -> Result<[G; OUT_319], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28682,8 +30283,8 @@ fn aiur_fn_297( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_297] = [__v_6]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_6]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28699,15 +30300,15 @@ fn aiur_fn_297( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_297] = [__v_10]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_10]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_297] = [__v_10]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_10]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28716,10 +30317,10 @@ fn aiur_fn_297( } }, _ => { - let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_297] = [__v_9]; - if let Some(result) = record.function_queries[297].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_319] = [__v_9]; + if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28733,15 +30334,15 @@ fn aiur_fn_297( }) } -const INPUT_SIZE_298: usize = 2; -const IN_298: usize = 2; -const OUT_298: usize = 1; -fn aiur_fn_298( - inp: [G; IN_298], +const INPUT_SIZE_320: usize = 2; +const IN_320: usize = 2; +const OUT_320: usize = 1; +fn aiur_fn_320( + inp: [G; IN_320], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_298], ExecError> { +) -> Result<[G; OUT_320], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28752,8 +30353,8 @@ fn aiur_fn_298( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_298] = [__v_5]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_5]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28769,7 +30370,7 @@ fn aiur_fn_298( break '__mc_0 [__v_8]; }, _ => { - let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; break '__mc_0 [__v_8]; }, @@ -28779,25 +30380,25 @@ fn aiur_fn_298( match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_9]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_9]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_298] = [__v_10]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_10]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_298] = [__v_10]; - if let Some(result) = record.function_queries[298].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_320] = [__v_10]; + if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28819,15 +30420,15 @@ fn aiur_fn_298( }) } -const INPUT_SIZE_299: usize = 3; -const IN_299: usize = 3; -const OUT_299: usize = 1; -fn aiur_fn_299( - inp: [G; IN_299], +const INPUT_SIZE_321: usize = 3; +const IN_321: usize = 3; +const OUT_321: usize = 1; +fn aiur_fn_321( + inp: [G; IN_321], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_299], ExecError> { +) -> Result<[G; OUT_321], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -28839,8 +30440,8 @@ fn aiur_fn_299( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_299] = [__v_6]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_6]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28849,20 +30450,20 @@ fn aiur_fn_299( let __v_7: G = __loaded[1]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_296(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_299] = [__v_9]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_9]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_299(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_299] = [__v_9]; - if let Some(result) = record.function_queries[299].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_321] = [__v_9]; + if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -28879,15 +30480,15 @@ fn aiur_fn_299( }) } -const INPUT_SIZE_300: usize = 1; -const IN_300: usize = 1; -const OUT_300: usize = 1; -fn aiur_fn_300( - inp: [G; IN_300], +const INPUT_SIZE_322: usize = 1; +const IN_322: usize = 1; +const OUT_322: usize = 1; +fn aiur_fn_322( + inp: [G; IN_322], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_300], ExecError> { +) -> Result<[G; OUT_322], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -28907,35 +30508,35 @@ fn aiur_fn_300( let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_288(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_300] = [__v_19]; - if let Some(result) = record.function_queries[300].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_322] = [__v_19]; + if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_301: usize = 2; -const IN_301: usize = 2; -const OUT_301: usize = 1; -fn aiur_fn_301( - inp: [G; IN_301], +const INPUT_SIZE_323: usize = 2; +const IN_323: usize = 2; +const OUT_323: usize = 1; +fn aiur_fn_323( + inp: [G; IN_323], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_301], ExecError> { +) -> Result<[G; OUT_323], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_301] = [__v_3]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_3]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -28946,19 +30547,19 @@ fn aiur_fn_301( match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_301] = [__v_6]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_6]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_301] = [__v_8]; - if let Some(result) = record.function_queries[301].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_323] = [__v_8]; + if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -28970,36 +30571,36 @@ fn aiur_fn_301( }) } -const INPUT_SIZE_302: usize = 2; -const IN_302: usize = 2; -const OUT_302: usize = 1; -fn aiur_fn_302( - inp: [G; IN_302], +const INPUT_SIZE_324: usize = 2; +const IN_324: usize = 2; +const OUT_324: usize = 1; +fn aiur_fn_324( + inp: [G; IN_324], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_302], ExecError> { +) -> Result<[G; OUT_324], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_302] = [__v_3]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_3]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_300(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_302] = [__v_5]; - if let Some(result) = record.function_queries[302].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_324] = [__v_5]; + if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29009,24 +30610,24 @@ fn aiur_fn_302( }) } -const INPUT_SIZE_303: usize = 2; -const IN_303: usize = 2; -const OUT_303: usize = 1; -fn aiur_fn_303( - inp: [G; IN_303], +const INPUT_SIZE_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_303], ExecError> { +) -> Result<[G; OUT_325], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -29034,13 +30635,13 @@ fn aiur_fn_303( let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_303] = [__v_1]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_1]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_303] = [__v_0]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_0]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29049,43 +30650,43 @@ fn aiur_fn_303( } }, _ => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_303] = [__v_6]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_6]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_304(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_303] = [__v_4]; - if let Some(result) = record.function_queries[303].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_325] = [__v_4]; + if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_304: usize = 2; -const IN_304: usize = 2; -const OUT_304: usize = 1; -fn aiur_fn_304( - inp: [G; IN_304], +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_304], ExecError> { +) -> Result<[G; OUT_326], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_304] = [__v_0]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_0]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29095,8 +30696,8 @@ fn aiur_fn_304( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_304] = [__v_1]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_1]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29106,33 +30707,33 @@ fn aiur_fn_304( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_304] = [__v_0]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_0]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_304] = [__v_1]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_1]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_306(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_328(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_304] = [__v_0]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_0]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_307(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_304] = [__v_11]; - if let Some(result) = record.function_queries[304].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_326] = [__v_11]; + if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29156,15 +30757,15 @@ fn aiur_fn_304( }) } -const INPUT_SIZE_305: usize = 2; -const IN_305: usize = 2; -const OUT_305: usize = 1; -fn aiur_fn_305( - inp: [G; IN_305], +const INPUT_SIZE_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_305], ExecError> { +) -> Result<[G; OUT_327], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29172,8 +30773,8 @@ fn aiur_fn_305( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_305] = [__v_3]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_3]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29190,14 +30791,14 @@ fn aiur_fn_305( match __v_6.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_305] = [__v_9]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_305] = [__v_9]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29209,16 +30810,16 @@ fn aiur_fn_305( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_305] = [__v_9]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_305] = [__v_9]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29230,19 +30831,19 @@ fn aiur_fn_305( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_305] = [__v_11]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_11]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_305] = [__v_9]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29254,19 +30855,19 @@ fn aiur_fn_305( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = (__v_9 * __v_10); - let __ret: [G; OUT_305] = [__v_11]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_11]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_305] = [__v_9]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29282,22 +30883,22 @@ fn aiur_fn_305( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_305] = [__v_10]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_10]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_305] = [__v_10]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_10]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_305] = [__v_9]; - if let Some(result) = record.function_queries[305].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_327] = [__v_9]; + if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29311,15 +30912,15 @@ fn aiur_fn_305( }) } -const INPUT_SIZE_306: usize = 2; -const IN_306: usize = 2; -const OUT_306: usize = 1; -fn aiur_fn_306( - inp: [G; IN_306], +const INPUT_SIZE_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_306], ExecError> { +) -> Result<[G; OUT_328], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29329,20 +30930,20 @@ fn aiur_fn_306( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_306] = [__v_6]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_6]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_306] = [__v_6]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_6]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29352,48 +30953,48 @@ fn aiur_fn_306( }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_306] = [__v_5]; - if let Some(result) = record.function_queries[306].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_328] = [__v_5]; + if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_307: usize = 2; -const IN_307: usize = 2; -const OUT_307: usize = 1; -fn aiur_fn_307( - inp: [G; IN_307], +const INPUT_SIZE_329: usize = 2; +const IN_329: usize = 2; +const OUT_329: usize = 1; +fn aiur_fn_329( + inp: [G; IN_329], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_307], ExecError> { +) -> Result<[G; OUT_329], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_307] = [__v_1]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_1]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_307] = [__v_0]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_0]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29404,8 +31005,8 @@ fn aiur_fn_307( 0u64 => { let __v_9: G = G::from_u64(2); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_307] = [__v_10]; - if let Some(result) = record.function_queries[307].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_329] = [__v_10]; + if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29415,15 +31016,15 @@ fn aiur_fn_307( }) } -const INPUT_SIZE_308: usize = 1; -const IN_308: usize = 1; -const OUT_308: usize = 2; -fn aiur_fn_308( - inp: [G; IN_308], +const INPUT_SIZE_330: usize = 1; +const IN_330: usize = 1; +const OUT_330: usize = 2; +fn aiur_fn_330( + inp: [G; IN_330], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_308], ExecError> { +) -> Result<[G; OUT_330], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -29434,12 +31035,12 @@ fn aiur_fn_308( 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_308] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_308(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -29447,15 +31048,15 @@ fn aiur_fn_308( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_5 + __v_7); - let __ret: [G; OUT_308] = [__v_6, __v_8]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_6, __v_8]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_308] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29463,23 +31064,23 @@ fn aiur_fn_308( _ => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_308] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[308].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_330] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_309: usize = 2; -const IN_309: usize = 2; -const OUT_309: usize = 2; -fn aiur_fn_309( - inp: [G; IN_309], +const INPUT_SIZE_331: usize = 2; +const IN_331: usize = 2; +const OUT_331: usize = 2; +fn aiur_fn_331( + inp: [G; IN_331], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_309], ExecError> { +) -> Result<[G; OUT_331], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29491,31 +31092,31 @@ fn aiur_fn_309( 1u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_309(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_309] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_331] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_309] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[309].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_331] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_310: usize = 2; -const IN_310: usize = 2; -const OUT_310: usize = 1; -fn aiur_fn_310( - inp: [G; IN_310], +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_310], ExecError> { +) -> Result<[G; OUT_332], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29528,26 +31129,26 @@ fn aiur_fn_310( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_310] = [__v_7]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_7]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_5]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_5]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_310] = [__v_6]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_6]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -29557,24 +31158,24 @@ fn aiur_fn_310( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_310] = [__v_1]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_1]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_276(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_298(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_310] = [__v_0]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_0]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(3); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_310] = [__v_11]; - if let Some(result) = record.function_queries[310].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_332] = [__v_11]; + if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29593,15 +31194,15 @@ fn aiur_fn_310( }) } -const INPUT_SIZE_311: usize = 1; -const IN_311: usize = 1; -const OUT_311: usize = 1; -fn aiur_fn_311( - inp: [G; IN_311], +const INPUT_SIZE_333: usize = 1; +const IN_333: usize = 1; +const OUT_333: usize = 1; +fn aiur_fn_333( + inp: [G; IN_333], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_311], ExecError> { +) -> Result<[G; OUT_333], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -29613,48 +31214,48 @@ fn aiur_fn_311( let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_6]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_6]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_4: G = G::from_u64(4); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_6]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_6]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_4, __v_5, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_311] = [__v_7]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_7]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_6]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_6]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_311] = [__v_6]; - if let Some(result) = record.function_queries[311].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_333] = [__v_6]; + if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29664,15 +31265,15 @@ fn aiur_fn_311( }) } -const INPUT_SIZE_312: usize = 2; -const IN_312: usize = 2; -const OUT_312: usize = 1; -fn aiur_fn_312( - inp: [G; IN_312], +const INPUT_SIZE_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_312], ExecError> { +) -> Result<[G; OUT_334], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29685,47 +31286,47 @@ fn aiur_fn_312( let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_312] = [__v_7]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_7]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_312] = [__v_8]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_8]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_303(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_312] = [__v_7]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_7]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_312] = [__v_7]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_7]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_312] = [__v_5]; - if let Some(result) = record.function_queries[312].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_334] = [__v_5]; + if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29735,15 +31336,15 @@ fn aiur_fn_312( }) } -const INPUT_SIZE_313: usize = 2; -const IN_313: usize = 2; -const OUT_313: usize = 1; -fn aiur_fn_313( - inp: [G; IN_313], +const INPUT_SIZE_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_313], ExecError> { +) -> Result<[G; OUT_335], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29756,19 +31357,19 @@ fn aiur_fn_313( 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_313] = [__v_7]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_7]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_313] = [__v_8]; - if let Some(result) = record.function_queries[313].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_335] = [__v_8]; + if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29778,15 +31379,15 @@ fn aiur_fn_313( }) } -const INPUT_SIZE_314: usize = 2; -const IN_314: usize = 2; -const OUT_314: usize = 1; -fn aiur_fn_314( - inp: [G; IN_314], +const INPUT_SIZE_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_314], ExecError> { +) -> Result<[G; OUT_336], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29796,30 +31397,30 @@ fn aiur_fn_314( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_314] = [__v_0]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_0]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_315(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_314] = [__v_5]; - if let Some(result) = record.function_queries[314].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_336] = [__v_5]; + if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_315: usize = 2; -const IN_315: usize = 2; -const OUT_315: usize = 1; -fn aiur_fn_315( - inp: [G; IN_315], +const INPUT_SIZE_337: usize = 2; +const IN_337: usize = 2; +const OUT_337: usize = 1; +fn aiur_fn_337( + inp: [G; IN_337], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_315], ExecError> { +) -> Result<[G; OUT_337], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29833,94 +31434,94 @@ fn aiur_fn_315( 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_315] = [__v_8]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_8]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_312(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_315] = [__v_9]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_9]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_313(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_3, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_315] = [__v_9]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_9]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_6: G = G::from_u64(3); - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_10]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_6: G = G::from_u64(4); - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_10]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_6: G = G::from_u64(5); - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_10]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(6); - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_315] = [__v_10]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_10]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(7); let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_315] = [__v_8]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_8]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_6: G = G::from_u64(8); - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_315] = [__v_8]; - if let Some(result) = record.function_queries[315].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_337] = [__v_8]; + if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -29930,15 +31531,15 @@ fn aiur_fn_315( }) } -const INPUT_SIZE_316: usize = 2; -const IN_316: usize = 2; -const OUT_316: usize = 1; -fn aiur_fn_316( - inp: [G; IN_316], +const INPUT_SIZE_338: usize = 2; +const IN_338: usize = 2; +const OUT_338: usize = 1; +fn aiur_fn_338( + inp: [G; IN_338], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_316], ExecError> { +) -> Result<[G; OUT_338], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -29969,14 +31570,14 @@ fn aiur_fn_316( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_316] = [__v_22]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_22]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_316] = [__v_22]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_22]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -29996,8 +31597,8 @@ fn aiur_fn_316( match __v_12.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_316] = [__v_22]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_22]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30005,16 +31606,16 @@ fn aiur_fn_316( let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_316] = [__v_23]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_23]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_316] = [__v_23]; - if let Some(result) = record.function_queries[316].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_338] = [__v_23]; + if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30034,15 +31635,15 @@ fn aiur_fn_316( }) } -const INPUT_SIZE_317: usize = 2; -const IN_317: usize = 2; -const OUT_317: usize = 1; -fn aiur_fn_317( - inp: [G; IN_317], +const INPUT_SIZE_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_317], ExecError> { +) -> Result<[G; OUT_339], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30059,14 +31660,14 @@ fn aiur_fn_317( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_317] = [__v_8]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_8]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_317] = [__v_8]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_8]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30079,24 +31680,24 @@ fn aiur_fn_317( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_317] = [__v_8]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_8]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = (__v_3 - __v_6); match __v_8.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_317] = [__v_9]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_9]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_317] = [__v_9]; - if let Some(result) = record.function_queries[317].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_339] = [__v_9]; + if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30113,15 +31714,15 @@ fn aiur_fn_317( }) } -const INPUT_SIZE_318: usize = 4; -const IN_318: usize = 4; -const OUT_318: usize = 1; -fn aiur_fn_318( - inp: [G; IN_318], +const INPUT_SIZE_340: usize = 4; +const IN_340: usize = 4; +const OUT_340: usize = 1; +fn aiur_fn_340( + inp: [G; IN_340], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_318], ExecError> { +) -> Result<[G; OUT_340], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30131,16 +31732,16 @@ fn aiur_fn_318( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_318] = [__v_4]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_4]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_318] = [__v_4]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_4]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30148,16 +31749,16 @@ fn aiur_fn_318( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_318] = [__v_4]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_4]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_318] = [__v_4]; - if let Some(result) = record.function_queries[318].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_340] = [__v_4]; + if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -30169,15 +31770,15 @@ fn aiur_fn_318( }) } -const INPUT_SIZE_319: usize = 1; -const IN_319: usize = 1; -const OUT_319: usize = 1; -fn aiur_fn_319( - inp: [G; IN_319], +const INPUT_SIZE_341: usize = 1; +const IN_341: usize = 1; +const OUT_341: usize = 1; +fn aiur_fn_341( + inp: [G; IN_341], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_319], ExecError> { +) -> Result<[G; OUT_341], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -30189,77 +31790,77 @@ fn aiur_fn_319( 0u64 => { let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 + __v_5); - let __ret: [G; OUT_319] = [__v_6]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_6]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_319] = [__v_5]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_5]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_319] = [__v_5]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_5]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_319] = [__v_5]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_5]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_7]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_7]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_8]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_8]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_8]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_8]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_320(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_5]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_5]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_319] = [__v_5]; - if let Some(result) = record.function_queries[319].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_341] = [__v_5]; + if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30269,59 +31870,59 @@ fn aiur_fn_319( }) } -const INPUT_SIZE_320: usize = 3; -const IN_320: usize = 3; -const OUT_320: usize = 1; -fn aiur_fn_320( - inp: [G; IN_320], +const INPUT_SIZE_342: usize = 3; +const IN_342: usize = 3; +const OUT_342: usize = 1; +fn aiur_fn_342( + inp: [G; IN_342], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_320], ExecError> { +) -> Result<[G; OUT_342], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_322(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_320] = [__v_8]; - if let Some(result) = record.function_queries[320].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_342] = [__v_8]; + if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_321: usize = 2; -const IN_321: usize = 2; -const OUT_321: usize = 1; -fn aiur_fn_321( - inp: [G; IN_321], +const INPUT_SIZE_343: usize = 2; +const IN_343: usize = 2; +const OUT_343: usize = 1; +fn aiur_fn_343( + inp: [G; IN_343], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_321], ExecError> { +) -> Result<[G; OUT_343], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_321] = [__v_1]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_1]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_321] = [__v_0]; - if let Some(result) = record.function_queries[321].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_343] = [__v_0]; + if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30331,57 +31932,57 @@ fn aiur_fn_321( }) } -const INPUT_SIZE_322: usize = 1; -const IN_322: usize = 1; -const OUT_322: usize = 1; -fn aiur_fn_322( - inp: [G; IN_322], +const INPUT_SIZE_344: usize = 1; +const IN_344: usize = 1; +const OUT_344: usize = 1; +fn aiur_fn_344( + inp: [G; IN_344], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_322], ExecError> { +) -> Result<[G; OUT_344], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_322] = [__v_1]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_344] = [__v_1]; + if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1); let __v_2: G = (__v_0 - __v_1); - let __ret: [G; OUT_322] = [__v_2]; - if let Some(result) = record.function_queries[322].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_344] = [__v_2]; + if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_323: usize = 2; -const IN_323: usize = 2; -const OUT_323: usize = 1; -fn aiur_fn_323( - inp: [G; IN_323], +const INPUT_SIZE_345: usize = 2; +const IN_345: usize = 2; +const OUT_345: usize = 1; +fn aiur_fn_345( + inp: [G; IN_345], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_323], ExecError> { +) -> Result<[G; OUT_345], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_323] = [__v_0]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_345] = [__v_0]; + if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_323] = [__v_1]; - if let Some(result) = record.function_queries[323].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_345] = [__v_1]; + if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30391,34 +31992,34 @@ fn aiur_fn_323( }) } -const INPUT_SIZE_324: usize = 2; -const IN_324: usize = 2; -const OUT_324: usize = 1; -fn aiur_fn_324( - inp: [G; IN_324], +const INPUT_SIZE_346: usize = 2; +const IN_346: usize = 2; +const OUT_346: usize = 1; +fn aiur_fn_346( + inp: [G; IN_346], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_324], ExecError> { +) -> Result<[G; OUT_346], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __ret: [G; OUT_324] = [__v_2]; - if let Some(result) = record.function_queries[324].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_346] = [__v_2]; + if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_325: usize = 3; -const IN_325: usize = 3; -const OUT_325: usize = 1; -fn aiur_fn_325( - inp: [G; IN_325], +const INPUT_SIZE_347: usize = 3; +const IN_347: usize = 3; +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_325], ExecError> { +) -> Result<[G; OUT_347], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30434,14 +32035,14 @@ fn aiur_fn_325( match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_325] = [__v_8]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_8]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; - let __ret: [G; OUT_325] = [__v_8]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_8]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30451,37 +32052,37 @@ fn aiur_fn_325( }, 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_325] = [__v_7]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_7]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_325] = [__v_7]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_7]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_325] = [__v_7]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_7]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_325] = [__v_8]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_8]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_325] = [__v_8]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_8]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30490,31 +32091,31 @@ fn aiur_fn_325( } }, 4u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_325] = [__v_7]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_7]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_326(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_325] = [__v_7]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_7]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_325] = [__v_7]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_7]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_325] = [__v_7]; - if let Some(result) = record.function_queries[325].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[325].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_347] = [__v_7]; + if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30524,27 +32125,27 @@ fn aiur_fn_325( }) } -const INPUT_SIZE_326: usize = 4; -const IN_326: usize = 4; -const OUT_326: usize = 1; -fn aiur_fn_326( - inp: [G; IN_326], +const INPUT_SIZE_348: usize = 4; +const IN_348: usize = 4; +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_326], ExecError> { +) -> Result<[G; OUT_348], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_326] = [__v_5]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_348] = [__v_5]; + if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30552,10 +32153,10 @@ fn aiur_fn_326( let __v_6: G = (__v_2 + __v_5); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_326] = [__v_9]; - if let Some(result) = record.function_queries[326].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_348] = [__v_9]; + if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30565,38 +32166,38 @@ fn aiur_fn_326( }) } -const INPUT_SIZE_327: usize = 5; -const IN_327: usize = 5; -const OUT_327: usize = 1; -fn aiur_fn_327( - inp: [G; IN_327], +const INPUT_SIZE_349: usize = 5; +const IN_349: usize = 5; +const OUT_349: usize = 1; +fn aiur_fn_349( + inp: [G; IN_349], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_327], ExecError> { +) -> Result<[G; OUT_349], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_327] = [__v_6]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_349] = [__v_6]; + if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_327] = [__v_7]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_349] = [__v_7]; + if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -30604,10 +32205,10 @@ fn aiur_fn_327( let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_327] = [__v_11]; - if let Some(result) = record.function_queries[327].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_349] = [__v_11]; + if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30622,60 +32223,60 @@ fn aiur_fn_327( }) } -const INPUT_SIZE_328: usize = 2; -const IN_328: usize = 2; -const OUT_328: usize = 1; -fn aiur_fn_328( - inp: [G; IN_328], +const INPUT_SIZE_350: usize = 2; +const IN_350: usize = 2; +const OUT_350: usize = 1; +fn aiur_fn_350( + inp: [G; IN_350], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_328], ExecError> { +) -> Result<[G; OUT_350], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_328] = [__v_4]; - if let Some(result) = record.function_queries[328].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_350] = [__v_4]; + if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_329: usize = 2; -const IN_329: usize = 2; -const OUT_329: usize = 1; -fn aiur_fn_329( - inp: [G; IN_329], +const INPUT_SIZE_351: usize = 2; +const IN_351: usize = 2; +const OUT_351: usize = 1; +fn aiur_fn_351( + inp: [G; IN_351], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_329], ExecError> { +) -> Result<[G; OUT_351], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_329] = [__v_2]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_351] = [__v_2]; + if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_329] = [__v_7]; - if let Some(result) = record.function_queries[329].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_351] = [__v_7]; + if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30685,15 +32286,15 @@ fn aiur_fn_329( }) } -const INPUT_SIZE_330: usize = 1; -const IN_330: usize = 1; -const OUT_330: usize = 1; -fn aiur_fn_330( - inp: [G; IN_330], +const INPUT_SIZE_352: usize = 1; +const IN_352: usize = 1; +const OUT_352: usize = 1; +fn aiur_fn_352( + inp: [G; IN_352], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_330], ExecError> { +) -> Result<[G; OUT_352], 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 }; @@ -30703,13 +32304,13 @@ fn aiur_fn_330( match __v_1.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_4 + __v_6); - let __ret: [G; OUT_330] = [__v_7]; - if let Some(result) = record.function_queries[330].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_352] = [__v_7]; + if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30719,44 +32320,44 @@ fn aiur_fn_330( }) } -const INPUT_SIZE_331: usize = 2; -const IN_331: usize = 2; -const OUT_331: usize = 1; -fn aiur_fn_331( - inp: [G; IN_331], +const INPUT_SIZE_353: usize = 2; +const IN_353: usize = 2; +const OUT_353: usize = 1; +fn aiur_fn_353( + inp: [G; IN_353], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_331], ExecError> { +) -> Result<[G; OUT_353], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_331] = [__v_2]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_353] = [__v_2]; + if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[330].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_330(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_331] = [__v_2]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_353] = [__v_2]; + if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[331].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_331(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_331] = [__v_7]; - if let Some(result) = record.function_queries[331].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_353] = [__v_7]; + if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30768,15 +32369,15 @@ fn aiur_fn_331( }) } -const INPUT_SIZE_332: usize = 2; -const IN_332: usize = 2; -const OUT_332: usize = 1; -fn aiur_fn_332( - inp: [G; IN_332], +const INPUT_SIZE_354: usize = 2; +const IN_354: usize = 2; +const OUT_354: usize = 1; +fn aiur_fn_354( + inp: [G; IN_354], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_332], ExecError> { +) -> Result<[G; OUT_354], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30785,31 +32386,31 @@ fn aiur_fn_332( 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_332] = [__v_4]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_354] = [__v_4]; + if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_332] = [__v_0]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_354] = [__v_0]; + if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[329].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_329(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_332] = [__v_7]; - if let Some(result) = record.function_queries[332].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_354] = [__v_7]; + if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30821,51 +32422,51 @@ fn aiur_fn_332( }) } -const INPUT_SIZE_333: usize = 2; -const IN_333: usize = 2; -const OUT_333: usize = 1; -fn aiur_fn_333( - inp: [G; IN_333], +const INPUT_SIZE_355: usize = 2; +const IN_355: usize = 2; +const OUT_355: usize = 1; +fn aiur_fn_355( + inp: [G; IN_355], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_333], ExecError> { +) -> Result<[G; OUT_355], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_333] = [__v_6]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_6]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_334(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_333] = [__v_6]; - if let Some(result) = record.function_queries[333].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_355] = [__v_6]; + if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_334: usize = 2; -const IN_334: usize = 2; -const OUT_334: usize = 1; -fn aiur_fn_334( - inp: [G; IN_334], +const INPUT_SIZE_356: usize = 2; +const IN_356: usize = 2; +const OUT_356: usize = 1; +fn aiur_fn_356( + inp: [G; IN_356], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_334], ExecError> { +) -> Result<[G; OUT_356], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -30876,19 +32477,19 @@ fn aiur_fn_334( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4294967295); - let __ret: [G; OUT_334] = [__v_7]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_7]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_7: G = (__v_3 - __v_1); - let __ret: [G; OUT_334] = [__v_7]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_7]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30898,59 +32499,59 @@ fn aiur_fn_334( }, 1u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_334] = [__v_6]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_6]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_334] = [__v_6]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_6]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_6: G = G::from_u64(4294967295); - let __ret: [G; OUT_334] = [__v_6]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_6]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_8]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_8]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_6]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_6]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[335].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_335(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_335] = unsafe { *(result.output.as_ptr() as *const [G; OUT_335]) }; __ret } } else { aiur_fn_335(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_6]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_6]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_6]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_6]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_334] = [__v_6]; - if let Some(result) = record.function_queries[334].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_356] = [__v_6]; + if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -30960,100 +32561,100 @@ fn aiur_fn_334( }) } -const INPUT_SIZE_335: usize = 3; -const IN_335: usize = 3; -const OUT_335: usize = 1; -fn aiur_fn_335( - inp: [G; IN_335], +const INPUT_SIZE_357: usize = 3; +const IN_357: usize = 3; +const OUT_357: usize = 1; +fn aiur_fn_357( + inp: [G; IN_357], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_335], ExecError> { +) -> Result<[G; OUT_357], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 + __v_4); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_335] = [__v_7]; - if let Some(result) = record.function_queries[335].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[335].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_357] = [__v_7]; + if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_336: usize = 4; -const IN_336: usize = 4; -const OUT_336: usize = 1; -fn aiur_fn_336( - inp: [G; IN_336], +const INPUT_SIZE_358: usize = 4; +const IN_358: usize = 4; +const OUT_358: usize = 1; +fn aiur_fn_358( + inp: [G; IN_358], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_336], ExecError> { +) -> Result<[G; OUT_358], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_336] = [__v_10]; - if let Some(result) = record.function_queries[336].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_358] = [__v_10]; + if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_337: usize = 3; -const IN_337: usize = 3; -const OUT_337: usize = 1; -fn aiur_fn_337( - inp: [G; IN_337], +const INPUT_SIZE_359: usize = 3; +const IN_359: usize = 3; +const OUT_359: usize = 1; +fn aiur_fn_359( + inp: [G; IN_359], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_337], ExecError> { +) -> Result<[G; OUT_359], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_337] = [__v_0]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_0]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_337] = [__v_0]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_0]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_360(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_337] = [__v_5]; - if let Some(result) = record.function_queries[337].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_359] = [__v_5]; + if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31065,15 +32666,15 @@ fn aiur_fn_337( }) } -const INPUT_SIZE_338: usize = 3; -const IN_338: usize = 3; -const OUT_338: usize = 1; -fn aiur_fn_338( - inp: [G; IN_338], +const INPUT_SIZE_360: usize = 3; +const IN_360: usize = 3; +const OUT_360: usize = 1; +fn aiur_fn_360( + inp: [G; IN_360], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_338], ExecError> { +) -> Result<[G; OUT_360], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31085,90 +32686,90 @@ fn aiur_fn_338( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_7]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_7]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 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_338] = [__v_9]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_7: G = G::from_u64(2); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_338] = [__v_9]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_338] = [__v_11]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_11]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_338] = [__v_13]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_13]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_338] = [__v_13]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_13]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_338] = [__v_7]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_7]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 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_338] = [__v_9]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_338] = [__v_9]; - if let Some(result) = record.function_queries[338].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_360] = [__v_9]; + if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31178,15 +32779,15 @@ fn aiur_fn_338( }) } -const INPUT_SIZE_339: usize = 3; -const IN_339: usize = 3; -const OUT_339: usize = 1; -fn aiur_fn_339( - inp: [G; IN_339], +const INPUT_SIZE_361: usize = 3; +const IN_361: usize = 3; +const OUT_361: usize = 1; +fn aiur_fn_361( + inp: [G; IN_361], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_339], ExecError> { +) -> Result<[G; OUT_361], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31197,8 +32798,8 @@ fn aiur_fn_339( 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_339] = [__v_6]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_6]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -31206,8 +32807,8 @@ fn aiur_fn_339( let __v_5: G = (__v_0 + __v_1); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_339] = [__v_7]; - if let Some(result) = record.function_queries[339].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_361] = [__v_7]; + if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31217,15 +32818,15 @@ fn aiur_fn_339( }) } -const INPUT_SIZE_340: usize = 5; -const IN_340: usize = 5; -const OUT_340: usize = 1; -fn aiur_fn_340( - inp: [G; IN_340], +const INPUT_SIZE_362: usize = 5; +const IN_362: usize = 5; +const OUT_362: usize = 1; +fn aiur_fn_362( + inp: [G; IN_362], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_340], ExecError> { +) -> Result<[G; OUT_362], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31233,56 +32834,56 @@ fn aiur_fn_340( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_340] = [__v_11]; - if let Some(result) = record.function_queries[340].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_362] = [__v_11]; + if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_341: usize = 3; -const IN_341: usize = 3; -const OUT_341: usize = 1; -fn aiur_fn_341( - inp: [G; IN_341], +const INPUT_SIZE_363: usize = 3; +const IN_363: usize = 3; +const OUT_363: usize = 1; +fn aiur_fn_363( + inp: [G; IN_363], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_341], ExecError> { +) -> Result<[G; OUT_363], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_341] = [__v_0]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_0]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_341] = [__v_0]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_0]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_342(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_341] = [__v_5]; - if let Some(result) = record.function_queries[341].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_363] = [__v_5]; + if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31294,171 +32895,362 @@ fn aiur_fn_341( }) } -const INPUT_SIZE_342: usize = 3; -const IN_342: usize = 3; -const OUT_342: usize = 1; -fn aiur_fn_342( - inp: [G; IN_342], +const INPUT_SIZE_364: usize = 3; +const IN_364: usize = 3; +const OUT_364: usize = 1; +fn aiur_fn_364( + inp: [G; IN_364], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(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_364] = [__v_0]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 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_364] = [__v_11]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + 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_364] = [__v_9]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 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_364] = [__v_9]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 3u64 => { + let __v_7: G = G::from_u64(3); + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_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_364] = [__v_11]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 4u64 => { + let __v_7: G = G::from_u64(4); + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_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_363] = { let __args: [G; IN_363] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_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_364] = [__v_13]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 5u64 => { + let __v_7: G = G::from_u64(5); + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_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_363] = { let __args: [G; IN_363] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_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_364] = [__v_13]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 6u64 => { + let __v_7: G = G::from_u64(6); + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_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_363] = { let __args: [G; IN_363] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_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_364] = [__v_13]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 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_364] = [__v_9]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 8u64 => { + let __v_7: G = G::from_u64(8); + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_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_364] = [__v_9]; + if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_365: usize = 2; +const IN_365: usize = 2; +const OUT_365: usize = 1; +fn aiur_fn_365( + inp: [G; IN_365], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_365], 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 = (__v_3 - __v_1); + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_365] = [__v_7]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_365] = [__v_7]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + 3u64 => { + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_365] = [__v_7]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_365] = [__v_7]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_365] = [__v_6]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_365] = [__v_6]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_365] = [__v_6]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_365] = [__v_6]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_365] = [__v_6]; + if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_366: usize = 3; +const IN_366: usize = 3; +const OUT_366: usize = 1; +fn aiur_fn_366( + inp: [G; IN_366], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_366], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(1); + let __ret: [G; OUT_366] = [__v_4]; + if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(1); + let __v_5: G = (__v_2 + __v_4); + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_366] = [__v_6]; + if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_367: usize = 4; +const IN_367: usize = 4; +const OUT_367: usize = 1; +fn aiur_fn_367( + inp: [G; IN_367], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_342], ExecError> { +) -> Result<[G; OUT_367], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(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() { + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_367] = [__v_5]; + if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_342] = [__v_0]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - 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_342] = [__v_11]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_367] = [__v_6]; + if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_3 + __v_6); + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_367] = [__v_8]; + if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); }, } }, - 1u64 => { - let __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_342] = [__v_9]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 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_342] = [__v_9]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 3u64 => { - let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - let __v_10: G = G::from_u64(0); - 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_342] = [__v_11]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 4u64 => { - let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; - let __v_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_341] = { let __args: [G; IN_341] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; - let __v_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_342] = [__v_13]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 5u64 => { - let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; - let __v_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_341] = { let __args: [G; IN_341] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; - let __v_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_342] = [__v_13]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 6u64 => { - let __v_7: G = G::from_u64(6); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; - let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; - let __v_9: G = __r_arr[0]; - let __v_10: G = G::from_u64(1); - let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; - let __v_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_342] = [__v_13]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 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_342] = [__v_9]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 8u64 => { - let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; - let __v_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_342] = [__v_9]; - if let Some(result) = record.function_queries[342].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - _ => { - return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); - }, } }) } -const INPUT_SIZE_343: usize = 3; -const IN_343: usize = 3; -const OUT_343: usize = 1; -fn aiur_fn_343( - inp: [G; IN_343], +const INPUT_SIZE_368: usize = 3; +const IN_368: usize = 3; +const OUT_368: usize = 1; +fn aiur_fn_368( + inp: [G; IN_368], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_343], ExecError> { +) -> Result<[G; OUT_368], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_343] = [__v_0]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_368] = [__v_0]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_344(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_365(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_343] = [__v_5]; - if let Some(result) = record.function_queries[343].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + match __v_5.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_369(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_368] = [__v_6]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_2 + __v_7); + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_368] = [__v_9]; + if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } }, _ => { return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); @@ -31467,15 +33259,15 @@ fn aiur_fn_343( }) } -const INPUT_SIZE_344: usize = 3; -const IN_344: usize = 3; -const OUT_344: usize = 1; -fn aiur_fn_344( - inp: [G; IN_344], +const INPUT_SIZE_369: usize = 3; +const IN_369: usize = 3; +const OUT_369: usize = 1; +fn aiur_fn_369( + inp: [G; IN_369], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_344], ExecError> { +) -> Result<[G; OUT_369], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31487,90 +33279,90 @@ fn aiur_fn_344( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_370(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_7]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_7]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 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_344] = [__v_9]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_9]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 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_344] = [__v_9]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_9]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_344] = [__v_11]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_11]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_344] = [__v_13]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_13]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_2 + __v_9); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_7, __v_8, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_344] = [__v_13]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_13]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_344] = [__v_7]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_7]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 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_344] = [__v_9]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_9]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_344] = [__v_9]; - if let Some(result) = record.function_queries[344].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_369] = [__v_9]; + if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31580,28 +33372,28 @@ fn aiur_fn_344( }) } -const INPUT_SIZE_345: usize = 3; -const IN_345: usize = 3; -const OUT_345: usize = 1; -fn aiur_fn_345( - inp: [G; IN_345], +const INPUT_SIZE_370: usize = 3; +const IN_370: usize = 3; +const OUT_370: usize = 1; +fn aiur_fn_370( + inp: [G; IN_370], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_345], ExecError> { +) -> Result<[G; OUT_370], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_345] = [__v_6]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_6]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -31609,10 +33401,10 @@ fn aiur_fn_345( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_345] = [__v_6]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_6]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31621,8 +33413,8 @@ fn aiur_fn_345( let __v_7: G = (__v_0 - __v_6); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_5, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_345] = [__v_9]; - if let Some(result) = record.function_queries[345].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_370] = [__v_9]; + if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -31634,15 +33426,15 @@ fn aiur_fn_345( }) } -const INPUT_SIZE_346: usize = 5; -const IN_346: usize = 5; -const OUT_346: usize = 1; -fn aiur_fn_346( - inp: [G; IN_346], +const INPUT_SIZE_371: usize = 5; +const IN_371: usize = 5; +const OUT_371: usize = 1; +fn aiur_fn_371( + inp: [G; IN_371], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_346], ExecError> { +) -> Result<[G; OUT_371], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31650,85 +33442,111 @@ fn aiur_fn_346( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_346] = [__v_11]; - if let Some(result) = record.function_queries[346].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_371] = [__v_11]; + if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_347: usize = 3; -const IN_347: usize = 3; -const OUT_347: usize = 1; -fn aiur_fn_347( - inp: [G; IN_347], +const INPUT_SIZE_372: usize = 3; +const IN_372: usize = 3; +const OUT_372: usize = 1; +fn aiur_fn_372( + inp: [G; IN_372], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_347], ExecError> { +) -> Result<[G; OUT_372], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; - let __v_4: G = __r_arr[0]; - match __v_4.as_canonical_u64() { + match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_347] = [__v_0]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }, - 1u64 => { - let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_349(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; - let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_347] = [__v_5]; - if let Some(result) = record.function_queries[347].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_372] = [__v_0]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_372] = [__v_0]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 1u64 => { + let __v_6: G = (__v_2 + __v_3); + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_372] = [__v_8]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_8: G = (__v_2 + __v_3); + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_372] = [__v_9]; + if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } }, } }) } -const INPUT_SIZE_348: usize = 3; -const IN_348: usize = 3; -const OUT_348: usize = 1; -fn aiur_fn_348( - inp: [G; IN_348], +const INPUT_SIZE_373: usize = 3; +const IN_373: usize = 3; +const OUT_373: usize = 1; +fn aiur_fn_373( + inp: [G; IN_373], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_348], ExecError> { +) -> Result<[G; OUT_373], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_348] = [__v_8]; - if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_8]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -31736,8 +33554,8 @@ fn aiur_fn_348( let __v_7: G = (__v_0 - __v_3); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_348] = [__v_9]; - if let Some(result) = record.function_queries[348].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_373] = [__v_9]; + if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31747,15 +33565,15 @@ fn aiur_fn_348( }) } -const INPUT_SIZE_349: usize = 3; -const IN_349: usize = 3; -const OUT_349: usize = 1; -fn aiur_fn_349( - inp: [G; IN_349], +const INPUT_SIZE_374: usize = 3; +const IN_374: usize = 3; +const OUT_374: usize = 1; +fn aiur_fn_374( + inp: [G; IN_374], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_349], ExecError> { +) -> Result<[G; OUT_374], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31767,90 +33585,90 @@ fn aiur_fn_349( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[348].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_348(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_348] = unsafe { *(result.output.as_ptr() as *const [G; OUT_348]) }; __ret } } else { aiur_fn_348(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_373(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_349] = [__v_7]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_7]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 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_349] = [__v_9]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_9]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 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_349] = [__v_9]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_9]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_7: G = G::from_u64(3); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_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_349] = [__v_11]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_11]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_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_347] = { let __args: [G; IN_347] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_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_349] = [__v_13]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_13]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_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_347] = { let __args: [G; IN_347] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_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_349] = [__v_13]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_13]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_350(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_349] = [__v_7]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_7]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 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_349] = [__v_9]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_9]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { let __v_7: G = G::from_u64(8); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_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_349] = [__v_9]; - if let Some(result) = record.function_queries[349].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_374] = [__v_9]; + if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31860,15 +33678,15 @@ fn aiur_fn_349( }) } -const INPUT_SIZE_350: usize = 5; -const IN_350: usize = 5; -const OUT_350: usize = 1; -fn aiur_fn_350( - inp: [G; IN_350], +const INPUT_SIZE_375: usize = 5; +const IN_375: usize = 5; +const OUT_375: usize = 1; +fn aiur_fn_375( + inp: [G; IN_375], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_350], ExecError> { +) -> Result<[G; OUT_375], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31876,30 +33694,30 @@ fn aiur_fn_350( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(6); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_4 + __v_8); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_350] = [__v_11]; - if let Some(result) = record.function_queries[350].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_375] = [__v_11]; + if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_351: usize = 3; -const IN_351: usize = 3; -const OUT_351: usize = 3; -fn aiur_fn_351( - inp: [G; IN_351], +const INPUT_SIZE_376: usize = 3; +const IN_376: usize = 3; +const OUT_376: usize = 3; +fn aiur_fn_376( + inp: [G; IN_376], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_351], ExecError> { +) -> Result<[G; OUT_376], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31919,17 +33737,17 @@ fn aiur_fn_351( 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_351] = { let __args: [G; IN_351] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_351] = [__v_12, __v_13, __v_14]; - if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_376] = [__v_12, __v_13, __v_14]; + if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_351] = [__v_0, __v_2, __v_1]; - if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_376] = [__v_0, __v_2, __v_1]; + if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -31938,23 +33756,23 @@ fn aiur_fn_351( } }, _ => { - let __ret: [G; OUT_351] = [__v_0, __v_2, __v_1]; - if let Some(result) = record.function_queries[351].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_376] = [__v_0, __v_2, __v_1]; + if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_352: usize = 3; -const IN_352: usize = 3; -const OUT_352: usize = 1; -fn aiur_fn_352( - inp: [G; IN_352], +const INPUT_SIZE_377: usize = 3; +const IN_377: usize = 3; +const OUT_377: usize = 1; +fn aiur_fn_377( + inp: [G; IN_377], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_352], ExecError> { +) -> Result<[G; OUT_377], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -31962,56 +33780,56 @@ fn aiur_fn_352( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_352] = [__v_10]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_377] = [__v_10]; + if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_352] = [__v_14]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_377] = [__v_14]; + if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_352] = [__v_12]; - if let Some(result) = record.function_queries[352].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_377] = [__v_12]; + if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_353: usize = 3; -const IN_353: usize = 3; -const OUT_353: usize = 1; -fn aiur_fn_353( - inp: [G; IN_353], +const INPUT_SIZE_378: usize = 3; +const IN_378: usize = 3; +const OUT_378: usize = 1; +fn aiur_fn_378( + inp: [G; IN_378], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_353], ExecError> { +) -> Result<[G; OUT_378], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32026,87 +33844,87 @@ fn aiur_fn_353( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_353] = [__v_10]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_10]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_352(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_353] = [__v_7]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_7]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_353] = [__v_7]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_7]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_353] = [__v_9]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_9]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_353] = [__v_7]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_7]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_353] = [__v_7]; - if let Some(result) = record.function_queries[353].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_378] = [__v_7]; + if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_354: usize = 5; -const IN_354: usize = 5; -const OUT_354: usize = 1; -fn aiur_fn_354( - inp: [G; IN_354], +const INPUT_SIZE_379: usize = 5; +const IN_379: usize = 5; +const OUT_379: usize = 1; +fn aiur_fn_379( + inp: [G; IN_379], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_354], ExecError> { +) -> Result<[G; OUT_379], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_354] = [__v_11]; - if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_379] = [__v_11]; + if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32117,7 +33935,7 @@ fn aiur_fn_354( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -32135,21 +33953,21 @@ fn aiur_fn_354( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_354] = [__v_30]; - if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_379] = [__v_30]; + if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_354] = [__v_30]; - if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_379] = [__v_30]; + if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32157,10 +33975,10 @@ fn aiur_fn_354( _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_354] = [__v_17]; - if let Some(result) = record.function_queries[354].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_379] = [__v_17]; + if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32169,15 +33987,15 @@ fn aiur_fn_354( }) } -const INPUT_SIZE_355: usize = 0; -const IN_355: usize = 0; -const OUT_355: usize = 1; -fn aiur_fn_355( - inp: [G; IN_355], +const INPUT_SIZE_380: usize = 0; +const IN_380: usize = 0; +const OUT_380: usize = 1; +fn aiur_fn_380( + inp: [G; IN_380], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_355], ExecError> { +) -> Result<[G; OUT_380], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(116); let __v_1: G = G::from_u64(89); @@ -32212,21 +34030,21 @@ fn aiur_fn_355( let __v_30: G = G::from_u64(91); let __v_31: G = G::from_u64(151); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_355] = [__v_32]; - if let Some(result) = record.function_queries[355].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_380] = [__v_32]; + if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_356: usize = 0; -const IN_356: usize = 0; -const OUT_356: usize = 1; -fn aiur_fn_356( - inp: [G; IN_356], +const INPUT_SIZE_381: usize = 0; +const IN_381: usize = 0; +const OUT_381: usize = 1; +fn aiur_fn_381( + inp: [G; IN_381], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_356], ExecError> { +) -> Result<[G; OUT_381], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(171); let __v_1: G = G::from_u64(55); @@ -32261,21 +34079,21 @@ fn aiur_fn_356( let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(25); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_356] = [__v_32]; - if let Some(result) = record.function_queries[356].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_381] = [__v_32]; + if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_357: usize = 0; -const IN_357: usize = 0; -const OUT_357: usize = 1; -fn aiur_fn_357( - inp: [G; IN_357], +const INPUT_SIZE_382: usize = 0; +const IN_382: usize = 0; +const OUT_382: usize = 1; +fn aiur_fn_382( + inp: [G; IN_382], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_357], ExecError> { +) -> Result<[G; OUT_382], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(57); let __v_1: G = G::from_u64(138); @@ -32310,21 +34128,21 @@ fn aiur_fn_357( let __v_30: G = G::from_u64(182); let __v_31: G = G::from_u64(49); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_357] = [__v_32]; - if let Some(result) = record.function_queries[357].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_382] = [__v_32]; + if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_358: usize = 0; -const IN_358: usize = 0; -const OUT_358: usize = 1; -fn aiur_fn_358( - inp: [G; IN_358], +const INPUT_SIZE_383: usize = 0; +const IN_383: usize = 0; +const OUT_383: usize = 1; +fn aiur_fn_383( + inp: [G; IN_383], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_358], ExecError> { +) -> Result<[G; OUT_383], 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); @@ -32359,21 +34177,21 @@ fn aiur_fn_358( 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_358] = [__v_32]; - if let Some(result) = record.function_queries[358].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_383] = [__v_32]; + if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_359: usize = 0; -const IN_359: usize = 0; -const OUT_359: usize = 1; -fn aiur_fn_359( - inp: [G; IN_359], +const INPUT_SIZE_384: usize = 0; +const IN_384: usize = 0; +const OUT_384: usize = 1; +fn aiur_fn_384( + inp: [G; IN_384], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_359], ExecError> { +) -> Result<[G; OUT_384], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(141); let __v_1: G = G::from_u64(196); @@ -32408,21 +34226,21 @@ fn aiur_fn_359( let __v_30: G = G::from_u64(123); let __v_31: G = G::from_u64(208); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_359] = [__v_32]; - if let Some(result) = record.function_queries[359].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_384] = [__v_32]; + if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_360: usize = 0; -const IN_360: usize = 0; -const OUT_360: usize = 1; -fn aiur_fn_360( - inp: [G; IN_360], +const INPUT_SIZE_385: usize = 0; +const IN_385: usize = 0; +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_360], ExecError> { +) -> Result<[G; OUT_385], 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); @@ -32457,27 +34275,27 @@ fn aiur_fn_360( 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_360] = [__v_32]; - if let Some(result) = record.function_queries[360].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_385] = [__v_32]; + if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_361: usize = 4; -const IN_361: usize = 4; -const OUT_361: usize = 2; -fn aiur_fn_361( - inp: [G; IN_361], +const INPUT_SIZE_386: usize = 4; +const IN_386: usize = 4; +const OUT_386: usize = 2; +fn aiur_fn_386( + inp: [G; IN_386], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_361], ExecError> { +) -> Result<[G; OUT_386], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -32488,8 +34306,8 @@ fn aiur_fn_361( 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_361] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32502,7 +34320,7 @@ fn aiur_fn_361( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 2u64 => { - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_356(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; @@ -32513,12 +34331,12 @@ fn aiur_fn_361( 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_361] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(5); let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -32529,25 +34347,25 @@ fn aiur_fn_361( 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_361] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(3); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(4); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -32581,7 +34399,7 @@ fn aiur_fn_361( let __v_45: G = G::from_u64(0); let __v_46: G = { let __values: [G; 4] = [__v_44, __v_39, __v_43, __v_45]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_47: G = G::from_u64(2); - let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = G::from_u64(1); let __v_50: G = G::from_u64(1); @@ -32610,13 +34428,13 @@ fn aiur_fn_361( let __v_73: G = G::from_u64(0); let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_24, __v_73]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_75: G = G::from_u64(5); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_74, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_361] = [__v_77, __v_78]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_77, __v_78]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32625,8 +34443,8 @@ fn aiur_fn_361( 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_361] = [__v_42, __v_46]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_42, __v_46]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32637,8 +34455,8 @@ fn aiur_fn_361( let __v_35: G = G::from_u64(0); let __v_36: G = G::from_u64(0); let __v_37: G = { let __values: [G; 4] = [__v_34, __v_35, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_361] = [__v_33, __v_37]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_33, __v_37]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32649,8 +34467,8 @@ fn aiur_fn_361( 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_361] = [__v_29, __v_33]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_29, __v_33]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32665,8 +34483,8 @@ fn aiur_fn_361( 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_361] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32677,8 +34495,8 @@ fn aiur_fn_361( 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_361] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[361].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_386] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32687,15 +34505,15 @@ fn aiur_fn_361( }) } -const INPUT_SIZE_362: usize = 1; -const IN_362: usize = 1; -const OUT_362: usize = 1; -fn aiur_fn_362( - inp: [G; IN_362], +const INPUT_SIZE_387: usize = 1; +const IN_387: usize = 1; +const OUT_387: usize = 1; +fn aiur_fn_387( + inp: [G; IN_387], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_362], ExecError> { +) -> Result<[G; OUT_387], 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 }; @@ -32705,10 +34523,10 @@ fn aiur_fn_362( let __v_4: G = __loaded[3]; match __v_1.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_362] = [__v_5]; - if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_5]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32723,23 +34541,23 @@ fn aiur_fn_362( let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 12] = [__v_5, __v_6, __v_12, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_362] = [__v_15]; - if let Some(result) = record.function_queries[362].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_387] = [__v_15]; + if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_363: usize = 2; -const IN_363: usize = 2; -const OUT_363: usize = 1; -fn aiur_fn_363( - inp: [G; IN_363], +const INPUT_SIZE_388: usize = 2; +const IN_388: usize = 2; +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_363], ExecError> { +) -> Result<[G; OUT_388], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -32752,19 +34570,19 @@ fn aiur_fn_363( 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_363] = [__v_7]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_7]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 3] = [__v_6, __v_5, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_363] = [__v_8]; - if let Some(result) = record.function_queries[363].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_388] = [__v_8]; + if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32774,22 +34592,22 @@ fn aiur_fn_363( }) } -const INPUT_SIZE_364: usize = 3; -const IN_364: usize = 3; -const OUT_364: usize = 2; -fn aiur_fn_364( - inp: [G; IN_364], +const INPUT_SIZE_389: usize = 3; +const IN_389: usize = 3; +const OUT_389: usize = 2; +fn aiur_fn_389( + inp: [G; IN_389], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_364], ExecError> { +) -> Result<[G; OUT_389], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_145(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -32810,31 +34628,31 @@ fn aiur_fn_364( 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_364] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_17, __v_20]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_17, __v_20]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32843,8 +34661,8 @@ fn aiur_fn_364( 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_364] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32863,33 +34681,33 @@ fn aiur_fn_364( 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_364] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(1); let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_121(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_364] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32898,8 +34716,8 @@ fn aiur_fn_364( 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_364] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32907,11 +34725,11 @@ fn aiur_fn_364( } }, _ => { - let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_264(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_264] = unsafe { *(result.output.as_ptr() as *const [G; OUT_264]) }; __ret } } else { aiur_fn_264(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_364] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[364].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_389] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -32920,19 +34738,19 @@ fn aiur_fn_364( }) } -const INPUT_SIZE_365: usize = 2; -const IN_365: usize = 2; -const OUT_365: usize = 1; -fn aiur_fn_365( - inp: [G; IN_365], +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_365], ExecError> { +) -> Result<[G; OUT_390], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -32940,8 +34758,8 @@ fn aiur_fn_365( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_365] = [__v_2]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_2]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -32951,26 +34769,26 @@ fn aiur_fn_365( let __v_8: G = __loaded[2]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_365] = [__v_2]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_2]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_12, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 3] = [__v_14, __v_13, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_365] = [__v_17]; - if let Some(result) = record.function_queries[365].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_390] = [__v_17]; + if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -32985,15 +34803,15 @@ fn aiur_fn_365( }) } -const INPUT_SIZE_366: usize = 1; -const IN_366: usize = 1; -const OUT_366: usize = 1; -fn aiur_fn_366( - inp: [G; IN_366], +const INPUT_SIZE_391: usize = 1; +const IN_391: usize = 1; +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_366], ExecError> { +) -> Result<[G; OUT_391], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_144(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; @@ -33016,7 +34834,7 @@ fn aiur_fn_366( break '__mc_0 [__v_5]; }, _ => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -33026,7 +34844,7 @@ fn aiur_fn_366( break '__mc_0 [__v_7]; }, _ => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -33036,7 +34854,7 @@ fn aiur_fn_366( break '__mc_0 [__v_9]; }, _ => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_148(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -33046,7 +34864,7 @@ fn aiur_fn_366( break '__mc_0 [__v_11]; }, _ => { - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_152(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_164(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -33056,7 +34874,7 @@ fn aiur_fn_366( break '__mc_0 [__v_13]; }, _ => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_151(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_163(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -33066,7 +34884,7 @@ fn aiur_fn_366( break '__mc_0 [__v_15]; }, _ => { - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_149(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; @@ -33076,7 +34894,7 @@ fn aiur_fn_366( break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_150(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_162(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; @@ -33086,7 +34904,7 @@ fn aiur_fn_366( break '__mc_0 [__v_19]; }, _ => { - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_170(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; @@ -33096,7 +34914,7 @@ fn aiur_fn_366( break '__mc_0 [__v_21]; }, _ => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_159(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; @@ -33106,7 +34924,7 @@ fn aiur_fn_366( break '__mc_0 [__v_23]; }, _ => { - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_153(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_165(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; @@ -33116,7 +34934,7 @@ fn aiur_fn_366( break '__mc_0 [__v_25]; }, _ => { - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_154(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_166(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; @@ -33126,7 +34944,7 @@ fn aiur_fn_366( break '__mc_0 [__v_27]; }, _ => { - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_155(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_167(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; @@ -33136,7 +34954,7 @@ fn aiur_fn_366( break '__mc_0 [__v_29]; }, _ => { - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_156(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_168(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; @@ -33146,7 +34964,7 @@ fn aiur_fn_366( break '__mc_0 [__v_31]; }, _ => { - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_157(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_169(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; @@ -33195,55 +35013,67 @@ fn aiur_fn_366( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_366] = [__v_4]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_4]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_207(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_366] = [__v_5]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_5]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_185(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_197(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(3); - let __ret: [G; OUT_366] = [__v_6]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_6]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_171(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_183(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(4); - let __ret: [G; OUT_366] = [__v_7]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_7]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_515(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(5); - let __ret: [G; OUT_366] = [__v_8]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_391] = [__v_8]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_366] = [__v_8]; - if let Some(result) = record.function_queries[366].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_242(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_242] = unsafe { *(result.output.as_ptr() as *const [G; OUT_242]) }; __ret } } else { aiur_fn_242(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(6); + let __ret: [G; OUT_391] = [__v_9]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_391] = [__v_9]; + if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } }, } }, @@ -33257,63 +35087,71 @@ fn aiur_fn_366( }) } -const INPUT_SIZE_367: usize = 4; -const IN_367: usize = 4; -const OUT_367: usize = 2; -fn aiur_fn_367( - inp: [G; IN_367], +const INPUT_SIZE_392: usize = 4; +const IN_392: usize = 4; +const OUT_392: usize = 2; +fn aiur_fn_392( + inp: [G; IN_392], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_367], ExecError> { +) -> Result<[G; OUT_392], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_364(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_367] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_208(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_220(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_367] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_191(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_203(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_367] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_174(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_186(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_367] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_521(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_367] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_253(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_253] = unsafe { *(result.output.as_ptr() as *const [G; OUT_253]) }; __ret } } else { aiur_fn_253(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_392] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33322,52 +35160,52 @@ fn aiur_fn_367( 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_367] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[367].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_392] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_368: usize = 3; -const IN_368: usize = 3; -const OUT_368: usize = 2; -fn aiur_fn_368( - inp: [G; IN_368], +const INPUT_SIZE_393: usize = 3; +const IN_393: usize = 3; +const OUT_393: usize = 2; +fn aiur_fn_393( + inp: [G; IN_393], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_368], ExecError> { +) -> Result<[G; OUT_393], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_369(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_394(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; - let __ret: [G; OUT_368] = [__v_5, __v_6]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_5, __v_6]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_360(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_370(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_368] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33376,8 +35214,8 @@ fn aiur_fn_368( 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_368] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[368].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_393] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33386,19 +35224,19 @@ fn aiur_fn_368( }) } -const INPUT_SIZE_369: usize = 2; -const IN_369: usize = 2; -const OUT_369: usize = 2; -fn aiur_fn_369( - inp: [G; IN_369], +const INPUT_SIZE_394: usize = 2; +const IN_394: usize = 2; +const OUT_394: usize = 2; +fn aiur_fn_394( + inp: [G; IN_394], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_369], ExecError> { +) -> Result<[G; OUT_394], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(6); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -33409,33 +35247,33 @@ fn aiur_fn_369( 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_369] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(5); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(6); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_369] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33444,8 +35282,8 @@ fn aiur_fn_369( 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_369] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[369].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_394] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33454,19 +35292,19 @@ fn aiur_fn_369( }) } -const INPUT_SIZE_370: usize = 2; -const IN_370: usize = 2; -const OUT_370: usize = 2; -fn aiur_fn_370( - inp: [G; IN_370], +const INPUT_SIZE_395: usize = 2; +const IN_395: usize = 2; +const OUT_395: usize = 2; +fn aiur_fn_395( + inp: [G; IN_395], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_370], ExecError> { +) -> Result<[G; OUT_395], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(5); let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -33477,33 +35315,33 @@ fn aiur_fn_370( 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_370] = [__v_5, __v_9]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_5, __v_9]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(3); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(4); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_371(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(5); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(3); let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 4] = [__v_14, __v_6, __v_10, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_370] = [__v_13, __v_17]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_13, __v_17]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33512,8 +35350,8 @@ fn aiur_fn_370( 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_370] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[370].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_395] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33522,19 +35360,19 @@ fn aiur_fn_370( }) } -const INPUT_SIZE_371: usize = 2; -const IN_371: usize = 2; -const OUT_371: usize = 2; -fn aiur_fn_371( - inp: [G; IN_371], +const INPUT_SIZE_396: usize = 2; +const IN_396: usize = 2; +const OUT_396: usize = 2; +fn aiur_fn_396( + inp: [G; IN_396], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_371], ExecError> { +) -> Result<[G; OUT_396], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -33546,13 +35384,13 @@ fn aiur_fn_371( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(3); let __v_13: G = (__v_11 - __v_12); @@ -33560,10 +35398,10 @@ fn aiur_fn_371( 0u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_371] = [__v_14, __v_16]; - if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_14, __v_16]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33572,8 +35410,8 @@ fn aiur_fn_371( 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_371] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33584,8 +35422,8 @@ fn aiur_fn_371( 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_371] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33596,47 +35434,47 @@ fn aiur_fn_371( 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_371] = [__v_9, __v_13]; - if let Some(result) = record.function_queries[371].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_396] = [__v_9, __v_13]; + if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_372: usize = 5; -const IN_372: usize = 5; -const OUT_372: usize = 1; -fn aiur_fn_372( - inp: [G; IN_372], +const INPUT_SIZE_397: usize = 5; +const IN_397: usize = 5; +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_372], ExecError> { +) -> Result<[G; OUT_397], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_7]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_7]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_372] = [__v_6]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_6]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -33653,52 +35491,52 @@ fn aiur_fn_372( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_373(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_22]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_22]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_23]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_23]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_20]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_20]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; match __v_20.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_22]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_22]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_22]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_22]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33709,10 +35547,10 @@ fn aiur_fn_372( let __v_22: G = (__v_21 + __v_12); let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; break '__mc_0 [__v_25, __v_26]; @@ -33727,46 +35565,46 @@ fn aiur_fn_372( let __v_24: G = __mc_out___mc_0[1]; match __v_23.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_372] = [__v_24]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_24]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; match __v_26.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_27, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_28]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_28]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_372] = [__v_27]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_27]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; match __v_28.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_29, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_29, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_30]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_30]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_372] = [__v_27]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_27]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33774,10 +35612,10 @@ fn aiur_fn_372( } }, _ => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_28]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_28]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33785,10 +35623,10 @@ fn aiur_fn_372( } }, _ => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_372] = [__v_20]; - if let Some(result) = record.function_queries[372].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_397] = [__v_20]; + if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33797,20 +35635,20 @@ fn aiur_fn_372( }) } -const INPUT_SIZE_373: usize = 2; -const IN_373: usize = 2; -const OUT_373: usize = 2; -fn aiur_fn_373( - inp: [G; IN_373], +const INPUT_SIZE_398: usize = 2; +const IN_398: usize = 2; +const OUT_398: usize = 2; +fn aiur_fn_398( + inp: [G; IN_398], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_373], ExecError> { +) -> Result<[G; OUT_398], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(0); - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -33818,7 +35656,7 @@ fn aiur_fn_373( let __v_7: G = __r_arr[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_9.as_canonical_u64() { @@ -33828,22 +35666,22 @@ fn aiur_fn_373( 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_373] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(8); let __v_12: G = { let __values: [G; 4] = [__v_11, __v_5, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_373] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33854,23 +35692,23 @@ fn aiur_fn_373( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_373] = [__v_8, __v_12]; - if let Some(result) = record.function_queries[373].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_398] = [__v_8, __v_12]; + if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_374: usize = 2; -const IN_374: usize = 2; -const OUT_374: usize = 5; -fn aiur_fn_374( - inp: [G; IN_374], +const INPUT_SIZE_399: usize = 2; +const IN_399: usize = 2; +const OUT_399: usize = 5; +fn aiur_fn_399( + inp: [G; IN_399], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_374], ExecError> { +) -> Result<[G; OUT_399], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -33883,14 +35721,14 @@ fn aiur_fn_374( 4u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_374(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_374] = unsafe { *(result.output.as_ptr() as *const [G; OUT_374]) }; __ret } } else { aiur_fn_374(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; let __v_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_374] = [__v_8, __v_9, __v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_399] = [__v_8, __v_9, __v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { @@ -33908,8 +35746,8 @@ fn aiur_fn_374( 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_374] = [__v_11, __v_1, __v_3, __v_4, __v_14]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_399] = [__v_11, __v_1, __v_3, __v_4, __v_14]; + if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -33950,8 +35788,8 @@ fn aiur_fn_374( let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); - let __ret: [G; OUT_374] = [__v_11, __v_12, __v_45, __v_46, __v_47]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_399] = [__v_11, __v_12, __v_45, __v_46, __v_47]; + if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -33994,8 +35832,8 @@ fn aiur_fn_374( let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __ret: [G; OUT_374] = [__v_10, __v_11, __v_44, __v_45, __v_46]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_399] = [__v_10, __v_11, __v_44, __v_45, __v_46]; + if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34038,23 +35876,23 @@ fn aiur_fn_374( let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_374] = [__v_6, __v_7, __v_40, __v_41, __v_42]; - if let Some(result) = record.function_queries[374].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_399] = [__v_6, __v_7, __v_40, __v_41, __v_42]; + if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_375: usize = 1; -const IN_375: usize = 1; -const OUT_375: usize = 1; -fn aiur_fn_375( - inp: [G; IN_375], +const INPUT_SIZE_400: usize = 1; +const IN_400: usize = 1; +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_375], ExecError> { +) -> Result<[G; OUT_400], 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 }; @@ -34078,8 +35916,8 @@ fn aiur_fn_375( let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_375] = [__v_12]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_12]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34102,37 +35940,37 @@ fn aiur_fn_375( let __v_19: G = G::from_u64(3); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_11, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_375] = [__v_21]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_21]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_375] = [__v_0]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_0]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_375] = [__v_0]; - if let Some(result) = record.function_queries[375].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_400] = [__v_0]; + if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_376: usize = 9; -const IN_376: usize = 9; -const OUT_376: usize = 2; -fn aiur_fn_376( - inp: [G; IN_376], +const INPUT_SIZE_401: usize = 9; +const IN_401: usize = 9; +const OUT_401: usize = 2; +fn aiur_fn_401( + inp: [G; IN_401], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_376], ExecError> { +) -> Result<[G; OUT_401], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34156,9 +35994,9 @@ fn aiur_fn_376( let __v_14: G = (__v_4 + __v_5); let __v_15: G = (__v_3 + __v_14); let __v_16: G = (__v_2 + __v_15); - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -34167,14 +36005,14 @@ fn aiur_fn_376( 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_376] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_377(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { @@ -34183,30 +36021,30 @@ fn aiur_fn_376( 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_376] = [__v_21, __v_25]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_21, __v_25]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = (__v_3 + __v_4); let __v_23: G = (__v_2 + __v_22); - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(1); let __v_26: G = (__v_16 + __v_25); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_28, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_29, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_376] = [__v_30, __v_31]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_30, __v_31]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34221,32 +36059,32 @@ fn aiur_fn_376( 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_376] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[376].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_401] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_377: usize = 5; -const IN_377: usize = 5; -const OUT_377: usize = 1; -fn aiur_fn_377( - inp: [G; IN_377], +const INPUT_SIZE_402: usize = 5; +const IN_402: usize = 5; +const OUT_402: usize = 1; +fn aiur_fn_402( + inp: [G; IN_402], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_377], ExecError> { +) -> Result<[G; OUT_402], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -34263,12 +36101,12 @@ fn aiur_fn_377( match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_377] = [__v_14]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_402] = [__v_14]; + if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -34285,27 +36123,27 @@ fn aiur_fn_377( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(2); let __v_29: G = G::from_u64(0); let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_32, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_377] = [__v_34]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_402] = [__v_34]; + if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(0); - let __ret: [G; OUT_377] = [__v_27]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_402] = [__v_27]; + if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34314,61 +36152,61 @@ fn aiur_fn_377( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_377] = [__v_13]; - if let Some(result) = record.function_queries[377].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_402] = [__v_13]; + if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_378: usize = 3; -const IN_378: usize = 3; -const OUT_378: usize = 1; -fn aiur_fn_378( - inp: [G; IN_378], +const INPUT_SIZE_403: usize = 3; +const IN_403: usize = 3; +const OUT_403: usize = 1; +fn aiur_fn_403( + inp: [G; IN_403], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_378], ExecError> { +) -> Result<[G; OUT_403], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 + __v_4); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_7, __v_2, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_378] = [__v_13]; - if let Some(result) = record.function_queries[378].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_403] = [__v_13]; + if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_379: usize = 2; -const IN_379: usize = 2; -const OUT_379: usize = 1; -fn aiur_fn_379( - inp: [G; IN_379], +const INPUT_SIZE_404: usize = 2; +const IN_404: usize = 2; +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_379], ExecError> { +) -> Result<[G; OUT_404], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; @@ -34380,7 +36218,7 @@ fn aiur_fn_379( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -34397,41 +36235,41 @@ fn aiur_fn_379( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_23, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_379] = [__v_24]; - if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_24]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_379] = [__v_2]; - if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_2]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_379] = [__v_2]; - if let Some(result) = record.function_queries[379].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_404] = [__v_2]; + if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_380: usize = 10; -const IN_380: usize = 10; -const OUT_380: usize = 2; -fn aiur_fn_380( - inp: [G; IN_380], +const INPUT_SIZE_405: usize = 10; +const IN_405: usize = 10; +const OUT_405: usize = 2; +fn aiur_fn_405( + inp: [G; IN_405], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_380], ExecError> { +) -> Result<[G; OUT_405], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34446,7 +36284,7 @@ fn aiur_fn_380( let __v_10: G = (__v_4 + __v_5); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_2 + __v_11); - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __a_val = __v_12.as_canonical_u64(); let __b_val = __v_13.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_14.as_canonical_u64() { @@ -34456,40 +36294,40 @@ fn aiur_fn_380( 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_380] = [__v_15, __v_19]; - if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_15, __v_19]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_240(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_240] = unsafe { *(result.output.as_ptr() as *const [G; OUT_240]) }; __ret } } else { aiur_fn_240(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_262(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_262] = unsafe { *(result.output.as_ptr() as *const [G; OUT_262]) }; __ret } } else { aiur_fn_262(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_380] = [__v_17, __v_16]; - if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_17, __v_16]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_379(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_237(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_259(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_381(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; match __v_22.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_6, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; @@ -34501,40 +36339,40 @@ fn aiur_fn_380( } match __v_26.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(2); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __ret: [G; OUT_380] = [__v_32, __v_33]; - if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_32, __v_33]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_28, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = (__v_3 + __v_4); let __v_33: G = (__v_2 + __v_32); - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_1, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = (__v_35 - __v_27); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_25, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(1); let __v_39: G = (__v_12 + __v_38); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_42, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(1); - let __ret: [G; OUT_380] = [__v_44, __v_43]; - if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_44, __v_43]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34543,13 +36381,13 @@ fn aiur_fn_380( } }, _ => { - let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_380] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[380].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_405] = [__v_27, __v_28]; + if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34560,15 +36398,15 @@ fn aiur_fn_380( }) } -const INPUT_SIZE_381: usize = 1; -const IN_381: usize = 1; -const OUT_381: usize = 4; -fn aiur_fn_381( - inp: [G; IN_381], +const INPUT_SIZE_406: usize = 1; +const IN_406: usize = 1; +const OUT_406: usize = 4; +fn aiur_fn_406( + inp: [G; IN_406], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_381], ExecError> { +) -> Result<[G; OUT_406], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; @@ -34581,7 +36419,7 @@ fn aiur_fn_381( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -34599,10 +36437,10 @@ fn aiur_fn_381( match __v_8.as_canonical_u64() { 6u64 => { let __v_20: G = G::from_u64(1); - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_381] = [__v_20, __v_13, __v_21, __v_2]; - if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_406] = [__v_20, __v_13, __v_21, __v_2]; + if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -34644,8 +36482,8 @@ fn aiur_fn_381( let __v_55: G = G::from_u64(1); let __v_56: G = G::from_u64(1); let __v_57: G = { let __values: [G; 3] = [__v_55, __v_56, __v_56]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_381] = [__v_20, __v_21, __v_54, __v_57]; - if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_406] = [__v_20, __v_21, __v_54, __v_57]; + if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34689,23 +36527,23 @@ fn aiur_fn_381( let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_381] = [__v_7, __v_8, __v_41, __v_44]; - if let Some(result) = record.function_queries[381].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_406] = [__v_7, __v_8, __v_41, __v_44]; + if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_382: usize = 2; -const IN_382: usize = 2; -const OUT_382: usize = 3; -fn aiur_fn_382( - inp: [G; IN_382], +const INPUT_SIZE_407: usize = 2; +const IN_407: usize = 2; +const OUT_407: usize = 3; +fn aiur_fn_407( + inp: [G; IN_407], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_382], ExecError> { +) -> Result<[G; OUT_407], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34723,8 +36561,8 @@ fn aiur_fn_382( 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_382] = [__v_7, __v_8, __v_12]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_7, __v_8, __v_12]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -34734,17 +36572,17 @@ fn aiur_fn_382( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_382] = [__v_8, __v_4, __v_5]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_8, __v_4, __v_5]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; - let __ret: [G; OUT_382] = [__v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[382].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_407] = [__v_8, __v_9, __v_10]; + if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34758,15 +36596,15 @@ fn aiur_fn_382( }) } -const INPUT_SIZE_383: usize = 9; -const IN_383: usize = 9; -const OUT_383: usize = 2; -fn aiur_fn_383( - inp: [G; IN_383], +const INPUT_SIZE_408: usize = 9; +const IN_408: usize = 9; +const OUT_408: usize = 2; +fn aiur_fn_408( + inp: [G; IN_408], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_383], ExecError> { +) -> Result<[G; OUT_408], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34790,8 +36628,8 @@ fn aiur_fn_383( 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_383] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -34808,8 +36646,8 @@ fn aiur_fn_383( 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_383] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -34818,7 +36656,7 @@ fn aiur_fn_383( let __v_19: G = (__v_3 + __v_4); let __v_20: G = (__v_19 + __v_5); let __v_21: G = (__v_20 + __v_6); - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; match __v_22.as_canonical_u64() { @@ -34828,12 +36666,12 @@ fn aiur_fn_383( let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(0); let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_383] = [__v_24, __v_28]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_24, __v_28]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -34856,7 +36694,7 @@ fn aiur_fn_383( 0u64 => { match __v_29.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; match __v_39.as_canonical_u64() { 1u64 => { @@ -34865,50 +36703,70 @@ fn aiur_fn_383( 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_383] = [__v_40, __v_44]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_40, __v_44]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_41, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - match __v_42.as_canonical_u64() { + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_346(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + match __v_43.as_canonical_u64() { 1u64 => { - let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); - let __v_47: G = { let __values: [G; 4] = [__v_44, __v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_383] = [__v_43, __v_47]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __v_47: G = G::from_u64(0); + let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_408] = [__v_44, __v_48]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; - let __v_43: G = __r_arr[0]; - let __v_44: G = (__v_3 + __v_4); - let __v_45: G = (__v_44 + __v_5); - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_2, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; - let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_43, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; - let __v_47: G = __r_arr[0]; - let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_47, __v_23, __v_40, __v_11, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; - let __v_49: G = __r_arr[0]; - let __v_50: G = G::from_u64(1); - let __v_51: G = (__v_21 + __v_50); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; - let __v_52: G = __r_arr[0]; - let __v_53: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; - let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_383] = [__v_53, __v_54]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_40, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_44, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + match __v_45.as_canonical_u64() { + 1u64 => { + 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_408] = [__v_46, __v_50]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __v_47: G = (__v_3 + __v_4); + let __v_48: G = (__v_47 + __v_5); + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = G::from_u64(0); + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __v_53: G = G::from_u64(1); + let __v_54: G = (__v_21 + __v_53); + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = G::from_u64(1); + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_52, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_56, __v_57]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } }, } }, @@ -34920,8 +36778,8 @@ fn aiur_fn_383( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_383] = [__v_39, __v_43]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_39, __v_43]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34932,8 +36790,8 @@ fn aiur_fn_383( let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_383] = [__v_39, __v_43]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_39, __v_43]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34944,8 +36802,8 @@ fn aiur_fn_383( let __v_39: G = G::from_u64(0); let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_38, __v_39, __v_40, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_383] = [__v_37, __v_41]; - if let Some(result) = record.function_queries[383].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_408] = [__v_37, __v_41]; + if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -34966,15 +36824,15 @@ fn aiur_fn_383( }) } -const INPUT_SIZE_384: usize = 2; -const IN_384: usize = 2; -const OUT_384: usize = 2; -fn aiur_fn_384( - inp: [G; IN_384], +const INPUT_SIZE_409: usize = 2; +const IN_409: usize = 2; +const OUT_409: usize = 2; +fn aiur_fn_409( + inp: [G; IN_409], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_384], ExecError> { +) -> Result<[G; OUT_409], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -34998,8 +36856,8 @@ fn aiur_fn_384( match __v_8.as_canonical_u64() { 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_384] = [__v_12, __v_9]; - if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_12, __v_9]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35037,8 +36895,8 @@ fn aiur_fn_384( let __v_43: G = G::from_u64(0); let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 32] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_384] = [__v_12, __v_45]; - if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_12, __v_45]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35078,8 +36936,8 @@ fn aiur_fn_384( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_384] = [__v_6, __v_39]; - if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_6, __v_39]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35094,11 +36952,11 @@ fn aiur_fn_384( 5u64 => { 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_384] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35136,8 +36994,8 @@ fn aiur_fn_384( let __v_37: G = G::from_u64(0); let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_384] = [__v_6, __v_39]; - if let Some(result) = record.function_queries[384].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_409] = [__v_6, __v_39]; + if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35146,15 +37004,15 @@ fn aiur_fn_384( }) } -const INPUT_SIZE_385: usize = 5; -const IN_385: usize = 5; -const OUT_385: usize = 1; -fn aiur_fn_385( - inp: [G; IN_385], +const INPUT_SIZE_410: usize = 5; +const IN_410: usize = 5; +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_385], ExecError> { +) -> Result<[G; OUT_410], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35164,8 +37022,8 @@ fn aiur_fn_385( let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_385] = [__v_0]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_410] = [__v_0]; + if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35176,28 +37034,28 @@ fn aiur_fn_385( 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_385] = { let __args: [G; IN_385] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_385] = [__v_13]; - if let Some(result) = record.function_queries[385].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_410] = [__v_13]; + if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_386: usize = 1; -const IN_386: usize = 1; -const OUT_386: usize = 1; -fn aiur_fn_386( - inp: [G; IN_386], +const INPUT_SIZE_411: usize = 1; +const IN_411: usize = 1; +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_386], ExecError> { +) -> Result<[G; OUT_411], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -35214,38 +37072,38 @@ fn aiur_fn_386( let __v_13: G = __loaded[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_386] = [__v_16]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_411] = [__v_16]; + if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_386] = [__v_14]; - if let Some(result) = record.function_queries[386].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_411] = [__v_14]; + if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_387: usize = 2; -const IN_387: usize = 2; -const OUT_387: usize = 1; -fn aiur_fn_387( - inp: [G; IN_387], +const INPUT_SIZE_412: usize = 2; +const IN_412: usize = 2; +const OUT_412: usize = 1; +fn aiur_fn_412( + inp: [G; IN_412], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_387], ExecError> { +) -> Result<[G; OUT_412], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -35298,10 +37156,10 @@ fn aiur_fn_387( _ => { match __v_2.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_387] = [__v_50]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_50]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35310,8 +37168,8 @@ fn aiur_fn_387( let __v_52: G = G::from_u64(1); let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_54: G = { let __values: [G; 3] = [__v_50, __v_0, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_387] = [__v_54]; - if let Some(result) = record.function_queries[387].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_412] = [__v_54]; + if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35320,15 +37178,15 @@ fn aiur_fn_387( }) } -const INPUT_SIZE_388: usize = 6; -const IN_388: usize = 6; -const OUT_388: usize = 1; -fn aiur_fn_388( - inp: [G; IN_388], +const INPUT_SIZE_413: usize = 6; +const IN_413: usize = 6; +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_388], ExecError> { +) -> Result<[G; OUT_413], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35340,12 +37198,12 @@ fn aiur_fn_388( match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_388] = [__v_7]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_7]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -35362,32 +37220,32 @@ fn aiur_fn_388( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; match __v_21.as_canonical_u64() { 1u64 => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_388] = [__v_22]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_22]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); let __v_23: G = (__v_5 + __v_22); - let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_388(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_388] = [__v_24]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_24]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(1); - let __ret: [G; OUT_388] = [__v_20]; - if let Some(result) = record.function_queries[388].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_413] = [__v_20]; + if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35396,22 +37254,22 @@ fn aiur_fn_388( }) } -const INPUT_SIZE_389: usize = 2; -const IN_389: usize = 2; -const OUT_389: usize = 1; -fn aiur_fn_389( - inp: [G; IN_389], +const INPUT_SIZE_414: usize = 2; +const IN_414: usize = 2; +const OUT_414: usize = 1; +fn aiur_fn_414( + inp: [G; IN_414], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_389], ExecError> { +) -> Result<[G; OUT_414], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_389] = [__v_0]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -35424,15 +37282,15 @@ fn aiur_fn_389( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_389(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_389] = [__v_8]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_8]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_389] = [__v_0]; - if let Some(result) = record.function_queries[389].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_414] = [__v_0]; + if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35441,15 +37299,15 @@ fn aiur_fn_389( }) } -const INPUT_SIZE_390: usize = 2; -const IN_390: usize = 2; -const OUT_390: usize = 1; -fn aiur_fn_390( - inp: [G; IN_390], +const INPUT_SIZE_415: usize = 2; +const IN_415: usize = 2; +const OUT_415: usize = 1; +fn aiur_fn_415( + inp: [G; IN_415], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_390], ExecError> { +) -> Result<[G; OUT_415], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35460,43 +37318,43 @@ fn aiur_fn_390( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_390] = [__v_7]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_7]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_390(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_390] = [__v_7]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_7]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_390] = [__v_6]; - if let Some(result) = record.function_queries[390].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_415] = [__v_6]; + if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_391: usize = 2; -const IN_391: usize = 2; -const OUT_391: usize = 1; -fn aiur_fn_391( - inp: [G; IN_391], +const INPUT_SIZE_416: usize = 2; +const IN_416: usize = 2; +const OUT_416: usize = 1; +fn aiur_fn_416( + inp: [G; IN_416], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_391], ExecError> { +) -> Result<[G; OUT_416], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35507,94 +37365,94 @@ fn aiur_fn_391( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_6]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_6]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_391] = [__v_7]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_7]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_7]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_7]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_391] = [__v_7]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_7]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_7]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_7]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_391] = [__v_7]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_7]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_7]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_7]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_391] = [__v_7]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_7]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_391] = [__v_8]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_8]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_8]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_8]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35602,31 +37460,31 @@ fn aiur_fn_391( } }, 8u64 => { - let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_391] = [__v_6]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_6]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_391] = [__v_6]; - if let Some(result) = record.function_queries[391].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_416] = [__v_6]; + if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_392: usize = 2; -const IN_392: usize = 2; -const OUT_392: usize = 1; -fn aiur_fn_392( - inp: [G; IN_392], +const INPUT_SIZE_417: usize = 2; +const IN_417: usize = 2; +const OUT_417: usize = 1; +fn aiur_fn_417( + inp: [G; IN_417], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_392], ExecError> { +) -> Result<[G; OUT_417], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35637,8 +37495,8 @@ fn aiur_fn_392( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_392] = [__v_5]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_5]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -35647,15 +37505,15 @@ fn aiur_fn_392( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_392] = [__v_6]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_6]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_392] = [__v_6]; - if let Some(result) = record.function_queries[392].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_417] = [__v_6]; + if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -35667,15 +37525,15 @@ fn aiur_fn_392( }) } -const INPUT_SIZE_393: usize = 2; -const IN_393: usize = 2; -const OUT_393: usize = 1; -fn aiur_fn_393( - inp: [G; IN_393], +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_393], ExecError> { +) -> Result<[G; OUT_418], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35686,80 +37544,80 @@ fn aiur_fn_393( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_393] = [__v_0]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_0]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_393] = [__v_0]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_0]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_393] = [__v_0]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_0]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_393] = [__v_0]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_0]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_393] = [__v_0]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_0]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_393] = [__v_11]; - if let Some(result) = record.function_queries[393].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_418] = [__v_11]; + if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_394: usize = 2; -const IN_394: usize = 2; -const OUT_394: usize = 1; -fn aiur_fn_394( - inp: [G; IN_394], +const INPUT_SIZE_419: usize = 2; +const IN_419: usize = 2; +const OUT_419: usize = 1; +fn aiur_fn_419( + inp: [G; IN_419], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_394], ExecError> { +) -> Result<[G; OUT_419], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = 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_353] = { let __args: [G; IN_353] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_353(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_378(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_394] = [__v_5]; - if let Some(result) = record.function_queries[394].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_419] = [__v_5]; + if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_395: usize = 2; -const IN_395: usize = 2; -const OUT_395: usize = 1; -fn aiur_fn_395( - inp: [G; IN_395], +const INPUT_SIZE_420: usize = 2; +const IN_420: usize = 2; +const OUT_420: usize = 1; +fn aiur_fn_420( + inp: [G; IN_420], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_395], ExecError> { +) -> Result<[G; OUT_420], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35770,57 +37628,57 @@ fn aiur_fn_395( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_395] = [__v_0]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_395] = [__v_0]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_395] = [__v_0]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_395] = [__v_0]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_395] = [__v_0]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_0]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __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_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_395] = [__v_11]; - if let Some(result) = record.function_queries[395].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_420] = [__v_11]; + if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_396: usize = 3; -const IN_396: usize = 3; -const OUT_396: usize = 1; -fn aiur_fn_396( - inp: [G; IN_396], +const INPUT_SIZE_421: usize = 3; +const IN_421: usize = 3; +const OUT_421: usize = 1; +fn aiur_fn_421( + inp: [G; IN_421], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_396], ExecError> { +) -> Result<[G; OUT_421], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35835,101 +37693,101 @@ fn aiur_fn_396( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_10]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_10]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_14]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_14]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_18]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_18]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_16]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_16]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_9]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_9]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_397(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_7]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_7]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_423(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_7]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_7]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_396] = [__v_7]; - if let Some(result) = record.function_queries[396].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_421] = [__v_7]; + if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_397: usize = 6; -const IN_397: usize = 6; -const OUT_397: usize = 1; -fn aiur_fn_397( - inp: [G; IN_397], +const INPUT_SIZE_422: usize = 6; +const IN_422: usize = 6; +const OUT_422: usize = 1; +fn aiur_fn_422( + inp: [G; IN_422], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_397], ExecError> { +) -> Result<[G; OUT_422], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -35937,7 +37795,7 @@ fn aiur_fn_397( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; @@ -35949,7 +37807,7 @@ fn aiur_fn_397( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -35967,50 +37825,50 @@ fn aiur_fn_397( match __v_14.as_canonical_u64() { 6u64 => { let __v_26: G = (__v_20 + __v_1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_396(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_28]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_28]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_26]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_26]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_397] = [__v_13]; - if let Some(result) = record.function_queries[397].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_422] = [__v_13]; + if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_398: usize = 5; -const IN_398: usize = 5; -const OUT_398: usize = 1; -fn aiur_fn_398( - inp: [G; IN_398], +const INPUT_SIZE_423: usize = 5; +const IN_423: usize = 5; +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_398], ExecError> { +) -> Result<[G; OUT_423], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -36027,48 +37885,48 @@ fn aiur_fn_398( let __v_17: G = __loaded[11]; match __v_6.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_398] = [__v_21]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_21]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_398] = [__v_21]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_21]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_398] = [__v_18]; - if let Some(result) = record.function_queries[398].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_423] = [__v_18]; + if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_399: usize = 2; -const IN_399: usize = 2; -const OUT_399: usize = 1; -fn aiur_fn_399( - inp: [G; IN_399], +const INPUT_SIZE_424: usize = 2; +const IN_424: usize = 2; +const OUT_424: usize = 1; +fn aiur_fn_424( + inp: [G; IN_424], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_399], ExecError> { +) -> Result<[G; OUT_424], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36079,80 +37937,80 @@ fn aiur_fn_399( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_399] = [__v_0]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_0]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_399] = [__v_0]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_0]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_399] = [__v_0]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_0]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_399] = [__v_0]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_0]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_399] = [__v_0]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_0]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_399] = [__v_11]; - if let Some(result) = record.function_queries[399].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_424] = [__v_11]; + if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_400: usize = 2; -const IN_400: usize = 2; -const OUT_400: usize = 1; -fn aiur_fn_400( - inp: [G; IN_400], +const INPUT_SIZE_425: usize = 2; +const IN_425: usize = 2; +const OUT_425: usize = 1; +fn aiur_fn_425( + inp: [G; IN_425], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_400], ExecError> { +) -> Result<[G; OUT_425], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = 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_401] = { let __args: [G; IN_401] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_400] = [__v_5]; - if let Some(result) = record.function_queries[400].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_425] = [__v_5]; + if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_401: usize = 3; -const IN_401: usize = 3; -const OUT_401: usize = 1; -fn aiur_fn_401( - inp: [G; IN_401], +const INPUT_SIZE_426: usize = 3; +const IN_426: usize = 3; +const OUT_426: usize = 1; +fn aiur_fn_426( + inp: [G; IN_426], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_401], ExecError> { +) -> Result<[G; OUT_426], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36167,65 +38025,65 @@ fn aiur_fn_401( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_10]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_426] = [__v_10]; + if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_402(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_7]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_426] = [__v_7]; + if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_404(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_7]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_426] = [__v_7]; + if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_9]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_426] = [__v_9]; + if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_403(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_7]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_426] = [__v_7]; + if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_401] = [__v_7]; - if let Some(result) = record.function_queries[401].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_426] = [__v_7]; + if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_402: usize = 3; -const IN_402: usize = 3; -const OUT_402: usize = 1; -fn aiur_fn_402( - inp: [G; IN_402], +const INPUT_SIZE_427: usize = 3; +const IN_427: usize = 3; +const OUT_427: usize = 1; +fn aiur_fn_427( + inp: [G; IN_427], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_402], ExecError> { +) -> Result<[G; OUT_427], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36233,78 +38091,78 @@ fn aiur_fn_402( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_351(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_402] = [__v_10]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_10]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_402] = [__v_14]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_14]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_402] = [__v_12]; - if let Some(result) = record.function_queries[402].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_427] = [__v_12]; + if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_403: usize = 5; -const IN_403: usize = 5; -const OUT_403: usize = 1; -fn aiur_fn_403( - inp: [G; IN_403], +const INPUT_SIZE_428: usize = 5; +const IN_428: usize = 5; +const OUT_428: usize = 1; +fn aiur_fn_428( + inp: [G; IN_428], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_403], ExecError> { +) -> Result<[G; OUT_428], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_219(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_231(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_361(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_403] = [__v_11]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_11]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36315,7 +38173,7 @@ fn aiur_fn_403( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_362(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_387(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -36333,21 +38191,21 @@ fn aiur_fn_403( match __v_16.as_canonical_u64() { 6u64 => { let __v_28: G = (__v_22 + __v_1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_403] = [__v_30]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_30]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_28: G = G::from_u64(8); let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_403] = [__v_30]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_30]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36355,10 +38213,10 @@ fn aiur_fn_403( _ => { let __v_15: G = G::from_u64(8); let __v_16: G = { let __values: [G; 4] = [__v_15, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_403] = [__v_17]; - if let Some(result) = record.function_queries[403].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_428] = [__v_17]; + if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36367,32 +38225,32 @@ fn aiur_fn_403( }) } -const INPUT_SIZE_404: usize = 5; -const IN_404: usize = 5; -const OUT_404: usize = 1; -fn aiur_fn_404( - inp: [G; IN_404], +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_404], ExecError> { +) -> Result<[G; OUT_429], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_366(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_391(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; break '__mc_0 [__v_8, __v_9]; @@ -36408,7 +38266,7 @@ fn aiur_fn_404( } }, _ => { - let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_367(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; break '__mc_0 [__v_6, __v_7]; @@ -36419,19 +38277,19 @@ fn aiur_fn_404( let __v_7: G = __mc_out___mc_0[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_8]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_8]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_404] = [__v_7]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_7]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -36448,43 +38306,43 @@ fn aiur_fn_404( let __v_20: G = __loaded[11]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_373(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_398(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_23]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_23]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_23]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_23]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_23]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_23]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_23]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_23]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36495,10 +38353,10 @@ fn aiur_fn_404( let __v_23: G = (__v_22 + __v_13); let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_17.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_11, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_11, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_409(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_376(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_401(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; break '__mc_1 [__v_26, __v_27]; @@ -36513,46 +38371,46 @@ fn aiur_fn_404( let __v_25: G = __mc_out___mc_1[1]; match __v_24.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_404] = [__v_25]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_25]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_380(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_405(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_28, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_28, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_29]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_29]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_404] = [__v_28]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_28]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; match __v_29.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_30, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_30, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_31]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_31]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_404] = [__v_28]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_28]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36560,10 +38418,10 @@ fn aiur_fn_404( } }, _ => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_29]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_29]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36571,10 +38429,10 @@ fn aiur_fn_404( } }, _ => { - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_404] = [__v_21]; - if let Some(result) = record.function_queries[404].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_429] = [__v_21]; + if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -36583,40 +38441,40 @@ fn aiur_fn_404( }) } -const INPUT_SIZE_405: usize = 2; -const IN_405: usize = 2; -const OUT_405: usize = 1; -fn aiur_fn_405( - inp: [G; IN_405], +const INPUT_SIZE_430: usize = 2; +const IN_430: usize = 2; +const OUT_430: usize = 1; +fn aiur_fn_430( + inp: [G; IN_430], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_405], ExecError> { +) -> Result<[G; OUT_430], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); let __v_4: G = (__v_1 + __v_3); let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_405] = [__v_6]; - if let Some(result) = record.function_queries[405].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_430] = [__v_6]; + if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_406: usize = 12; -const IN_406: usize = 12; -const OUT_406: usize = 1; -fn aiur_fn_406( - inp: [G; IN_406], +const INPUT_SIZE_431: usize = 12; +const IN_431: usize = 12; +const OUT_431: usize = 1; +fn aiur_fn_431( + inp: [G; IN_431], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_406], ExecError> { +) -> Result<[G; OUT_431], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36632,43 +38490,43 @@ fn aiur_fn_406( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_406] = [__v_1]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_1]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_406] = [__v_1]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_1]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_406] = [__v_1]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_1]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_406] = [__v_1]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_1]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_406] = [__v_1]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_1]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_406] = [__v_1]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_1]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_406] = [__v_1]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_1]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_406] = [__v_1]; - if let Some(result) = record.function_queries[406].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_431] = [__v_1]; + if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36678,15 +38536,15 @@ fn aiur_fn_406( }) } -const INPUT_SIZE_407: usize = 12; -const IN_407: usize = 12; -const OUT_407: usize = 1; -fn aiur_fn_407( - inp: [G; IN_407], +const INPUT_SIZE_432: usize = 12; +const IN_432: usize = 12; +const OUT_432: usize = 1; +fn aiur_fn_432( + inp: [G; IN_432], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_407], ExecError> { +) -> Result<[G; OUT_432], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -36702,43 +38560,43 @@ fn aiur_fn_407( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_407] = [__v_2]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_2]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_407] = [__v_2]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_2]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __ret: [G; OUT_407] = [__v_2]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_2]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_407] = [__v_2]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_2]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_407] = [__v_2]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_2]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_407] = [__v_2]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_2]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_407] = [__v_2]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_2]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_407] = [__v_2]; - if let Some(result) = record.function_queries[407].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_432] = [__v_2]; + if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36748,21 +38606,21 @@ fn aiur_fn_407( }) } -const INPUT_SIZE_408: usize = 2; -const IN_408: usize = 2; -const OUT_408: usize = 1; -fn aiur_fn_408( - inp: [G; IN_408], +const INPUT_SIZE_433: usize = 2; +const IN_433: usize = 2; +const OUT_433: usize = 1; +fn aiur_fn_433( + inp: [G; IN_433], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_408], ExecError> { +) -> Result<[G; OUT_433], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(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]; @@ -36771,15 +38629,15 @@ fn aiur_fn_408( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_5 + __v_9); let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_408] = [__v_12]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_12]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -36787,16 +38645,16 @@ fn aiur_fn_408( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_5, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_14]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_14]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -36811,23 +38669,23 @@ fn aiur_fn_408( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; if (__v_23 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_408] = [__v_24]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_24]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -36837,14 +38695,14 @@ fn aiur_fn_408( match __v_9.as_canonical_u64() { 5u64 => { let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_408] = [__v_14]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_14]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -36854,10 +38712,10 @@ fn aiur_fn_408( match __v_14.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_408] = [__v_19]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_19]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36870,67 +38728,67 @@ fn aiur_fn_408( 4u64 => { let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_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_408] = [__v_13]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_13]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_15]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_15]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_408] = [__v_10]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_10]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_14]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_14]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); let __v_11: G = G::from_u64(1); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 4] = [__v_8, __v_9, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_408] = [__v_14]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_14]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -36939,9 +38797,9 @@ fn aiur_fn_408( } }, 8u64 => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; @@ -36953,7 +38811,7 @@ fn aiur_fn_408( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -36974,7 +38832,7 @@ fn aiur_fn_408( match __v_17.as_canonical_u64() { 5u64 => { let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_24, __v_25, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_31: G = __loaded[0]; @@ -36995,15 +38853,15 @@ fn aiur_fn_408( } match __v_31.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_33, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; - let __ret: [G; OUT_408] = [__v_47]; - if let Some(result) = record.function_queries[408].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_433] = [__v_47]; + if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37028,15 +38886,15 @@ fn aiur_fn_408( }) } -const INPUT_SIZE_409: usize = 2; -const IN_409: usize = 2; -const OUT_409: usize = 1; -fn aiur_fn_409( - inp: [G; IN_409], +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_409], ExecError> { +) -> Result<[G; OUT_434], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37047,15 +38905,15 @@ fn aiur_fn_409( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_409] = [__v_10]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_10]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -37063,16 +38921,16 @@ fn aiur_fn_409( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_409] = [__v_12]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_12]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -37087,23 +38945,23 @@ fn aiur_fn_409( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__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[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__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[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__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[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_20, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_409] = [__v_22]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_22]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -37113,14 +38971,14 @@ fn aiur_fn_409( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_409] = [__v_12]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_12]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -37130,10 +38988,10 @@ fn aiur_fn_409( match __v_12.as_canonical_u64() { 5u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_409] = [__v_17]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_17]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37146,67 +39004,67 @@ fn aiur_fn_409( 4u64 => { let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_6, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(5); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_409] = [__v_11]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_11]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_410(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_409] = [__v_13]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_13]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_409] = [__v_8]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_8]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { match __v_3.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(2); - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_409] = [__v_12]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_12]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(2); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_409] = [__v_12]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_12]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37215,9 +39073,9 @@ fn aiur_fn_409( } }, 8u64 => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; @@ -37229,7 +39087,7 @@ fn aiur_fn_409( let __v_13: G = __loaded[3]; match __v_10.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -37250,7 +39108,7 @@ fn aiur_fn_409( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_22, __v_23, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_28.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_29: G = __loaded[0]; @@ -37271,15 +39129,15 @@ fn aiur_fn_409( } match __v_29.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_31, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_409] = [__v_45]; - if let Some(result) = record.function_queries[409].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_434] = [__v_45]; + if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37304,19 +39162,19 @@ fn aiur_fn_409( }) } -const INPUT_SIZE_410: usize = 2; -const IN_410: usize = 2; -const OUT_410: usize = 1; -fn aiur_fn_410( - inp: [G; IN_410], +const INPUT_SIZE_435: usize = 2; +const IN_435: usize = 2; +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_410], ExecError> { +) -> Result<[G; OUT_435], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -37325,12 +39183,12 @@ fn aiur_fn_410( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_410] = [__v_4]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_435] = [__v_4]; + if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __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]; @@ -37339,8 +39197,8 @@ fn aiur_fn_410( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_410] = [__v_9]; - if let Some(result) = record.function_queries[410].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_435] = [__v_9]; + if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37352,23 +39210,23 @@ fn aiur_fn_410( }) } -const INPUT_SIZE_411: usize = 3; -const IN_411: usize = 3; -const OUT_411: usize = 1; -fn aiur_fn_411( - inp: [G; IN_411], +const INPUT_SIZE_436: usize = 3; +const IN_436: usize = 3; +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_411], ExecError> { +) -> Result<[G; OUT_436], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_411] = [__v_0]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_436] = [__v_0]; + if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37386,14 +39244,14 @@ fn aiur_fn_411( match __v_7.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_2 - __v_12); - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_411] = [__v_14]; - if let Some(result) = record.function_queries[411].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_436] = [__v_14]; + if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37410,15 +39268,15 @@ fn aiur_fn_411( }) } -const INPUT_SIZE_412: usize = 5; -const IN_412: usize = 5; -const OUT_412: usize = 1; -fn aiur_fn_412( - inp: [G; IN_412], +const INPUT_SIZE_437: usize = 5; +const IN_437: usize = 5; +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_412], ExecError> { +) -> Result<[G; OUT_437], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37435,22 +39293,22 @@ fn aiur_fn_412( let __v_9: G = (__v_1 - __v_2); match __v_9.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_412] = [__v_6]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_437] = [__v_6]; + if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(8); let __v_11: G = { let __values: [G; 4] = [__v_10, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_2 + __v_14); - let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_412(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_412] = [__v_16]; - if let Some(result) = record.function_queries[412].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_437] = [__v_16]; + if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37462,15 +39320,15 @@ fn aiur_fn_412( }) } -const INPUT_SIZE_413: usize = 2; -const IN_413: usize = 2; -const OUT_413: usize = 1; -fn aiur_fn_413( - inp: [G; IN_413], +const INPUT_SIZE_438: usize = 2; +const IN_438: usize = 2; +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_413], ExecError> { +) -> Result<[G; OUT_438], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37487,14 +39345,14 @@ fn aiur_fn_413( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_413] = [__v_8]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_8]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_413] = [__v_8]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_8]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37507,25 +39365,25 @@ fn aiur_fn_413( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_413] = [__v_8]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_8]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_413] = [__v_9]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_9]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_413] = [__v_9]; - if let Some(result) = record.function_queries[413].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_438] = [__v_9]; + if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37542,15 +39400,15 @@ fn aiur_fn_413( }) } -const INPUT_SIZE_414: usize = 3; -const IN_414: usize = 3; -const OUT_414: usize = 1; -fn aiur_fn_414( - inp: [G; IN_414], +const INPUT_SIZE_439: usize = 3; +const IN_439: usize = 3; +const OUT_439: usize = 1; +fn aiur_fn_439( + inp: [G; IN_439], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_414], ExecError> { +) -> Result<[G; OUT_439], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37559,33 +39417,33 @@ fn aiur_fn_414( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_414] = [__v_4]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_4]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[321].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_321(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_414] = [__v_10]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_10]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_415(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_414] = [__v_7]; - if let Some(result) = record.function_queries[414].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_439] = [__v_7]; + if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37594,73 +39452,73 @@ fn aiur_fn_414( }) } -const INPUT_SIZE_415: usize = 4; -const IN_415: usize = 4; -const OUT_415: usize = 1; -fn aiur_fn_415( - inp: [G; IN_415], +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_415], ExecError> { +) -> Result<[G; OUT_440], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_12]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_12]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_3 - __v_10); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_416(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_415] = [__v_18]; - if let Some(result) = record.function_queries[415].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_440] = [__v_18]; + if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_416: usize = 3; -const IN_416: usize = 3; -const OUT_416: usize = 1; -fn aiur_fn_416( - inp: [G; IN_416], +const INPUT_SIZE_441: usize = 3; +const IN_441: usize = 3; +const OUT_441: usize = 1; +fn aiur_fn_441( + inp: [G; IN_441], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_416], ExecError> { +) -> Result<[G; OUT_441], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37668,65 +39526,65 @@ fn aiur_fn_416( let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_4]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_4]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_416] = [__v_4]; - if let Some(result) = record.function_queries[416].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_441] = [__v_4]; + if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_417: usize = 3; -const IN_417: usize = 3; -const OUT_417: usize = 1; -fn aiur_fn_417( - inp: [G; IN_417], +const INPUT_SIZE_442: usize = 3; +const IN_442: usize = 3; +const OUT_442: usize = 1; +fn aiur_fn_442( + inp: [G; IN_442], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_417], ExecError> { +) -> Result<[G; OUT_442], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_417] = [__v_4]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_4]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_425(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_450(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_417] = [__v_4]; - if let Some(result) = record.function_queries[417].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_442] = [__v_4]; + if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_418: usize = 3; -const IN_418: usize = 3; -const OUT_418: usize = 1; -fn aiur_fn_418( - inp: [G; IN_418], +const INPUT_SIZE_443: usize = 3; +const IN_443: usize = 3; +const OUT_443: usize = 1; +fn aiur_fn_443( + inp: [G; IN_443], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_418], ExecError> { +) -> Result<[G; OUT_443], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37754,33 +39612,33 @@ fn aiur_fn_418( let __v_15: G = (__v_8 - __v_12); match __v_15.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_418] = [__v_17]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_17]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = (__v_17 - __v_18); match __v_19.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_418] = [__v_20]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_20]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_418] = [__v_20]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_20]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37789,39 +39647,39 @@ fn aiur_fn_418( }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_418] = [__v_16]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_16]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_418] = [__v_15]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_15]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_418] = [__v_11]; - if let Some(result) = record.function_queries[418].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_443] = [__v_11]; + if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_419: usize = 3; -const IN_419: usize = 3; -const OUT_419: usize = 1; -fn aiur_fn_419( - inp: [G; IN_419], +const INPUT_SIZE_444: usize = 3; +const IN_444: usize = 3; +const OUT_444: usize = 1; +fn aiur_fn_444( + inp: [G; IN_444], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_419], ExecError> { +) -> Result<[G; OUT_444], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -37839,14 +39697,14 @@ fn aiur_fn_419( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_419] = [__v_9]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_9]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_419] = [__v_9]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_9]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37859,25 +39717,25 @@ fn aiur_fn_419( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_419] = [__v_9]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_9]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_419] = [__v_10]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_10]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_419(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_419] = [__v_10]; - if let Some(result) = record.function_queries[419].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_444] = [__v_10]; + if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37894,15 +39752,15 @@ fn aiur_fn_419( }) } -const INPUT_SIZE_420: usize = 1; -const IN_420: usize = 1; -const OUT_420: usize = 1; -fn aiur_fn_420( - inp: [G; IN_420], +const INPUT_SIZE_445: usize = 1; +const IN_445: usize = 1; +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_420], ExecError> { +) -> Result<[G; OUT_445], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; @@ -37916,14 +39774,14 @@ fn aiur_fn_420( 0u64 => { let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_129(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_5]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_5]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_420] = [__v_5]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_5]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -37933,29 +39791,29 @@ fn aiur_fn_420( let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_420] = [__v_6]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_6]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_420] = [__v_5]; - if let Some(result) = record.function_queries[420].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_445] = [__v_5]; + if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_421: usize = 1; -const IN_421: usize = 1; -const OUT_421: usize = 3; -fn aiur_fn_421( - inp: [G; IN_421], +const INPUT_SIZE_446: usize = 1; +const IN_446: usize = 1; +const OUT_446: usize = 3; +fn aiur_fn_446( + inp: [G; IN_446], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_421], ExecError> { +) -> Result<[G; OUT_446], 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 }; @@ -37971,10 +39829,10 @@ fn aiur_fn_421( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_5, __v_9, __v_3]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_5, __v_9, __v_3]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -37982,8 +39840,8 @@ fn aiur_fn_421( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_421] = [__v_5, __v_0, __v_8]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_5, __v_0, __v_8]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38002,15 +39860,15 @@ fn aiur_fn_421( let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = G::from_u64(1); let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_14, __v_12, __v_15]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_14, __v_12, __v_15]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38018,8 +39876,8 @@ fn aiur_fn_421( 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_421] = [__v_11, __v_0, __v_14]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_11, __v_0, __v_14]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38032,7 +39890,7 @@ fn aiur_fn_421( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_158(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; @@ -38047,7 +39905,7 @@ fn aiur_fn_421( 7u64 => { match __v_16.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -38056,14 +39914,14 @@ fn aiur_fn_421( let __v_22: G = G::from_u64(1); let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_21, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_114(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_421] = [__v_22, __v_20, __v_23]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_22, __v_20, __v_23]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_22: G = G::from_u64(1); - let __ret: [G; OUT_421] = [__v_22, __v_7, __v_17]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_22, __v_7, __v_17]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38073,8 +39931,8 @@ fn aiur_fn_421( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_421] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38084,8 +39942,8 @@ fn aiur_fn_421( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_421] = [__v_19, __v_0, __v_22]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_19, __v_0, __v_22]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38095,8 +39953,8 @@ fn aiur_fn_421( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_421] = [__v_15, __v_0, __v_18]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_15, __v_0, __v_18]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38106,8 +39964,8 @@ fn aiur_fn_421( 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_421] = [__v_13, __v_0, __v_16]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_13, __v_0, __v_16]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38117,8 +39975,8 @@ fn aiur_fn_421( 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_421] = [__v_9, __v_0, __v_12]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_9, __v_0, __v_12]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38128,46 +39986,46 @@ fn aiur_fn_421( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 10] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_421] = [__v_5, __v_0, __v_8]; - if let Some(result) = record.function_queries[421].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_446] = [__v_5, __v_0, __v_8]; + if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_422: usize = 3; -const IN_422: usize = 3; -const OUT_422: usize = 2; -fn aiur_fn_422( - inp: [G; IN_422], +const INPUT_SIZE_447: usize = 3; +const IN_447: usize = 3; +const OUT_447: usize = 2; +fn aiur_fn_447( + inp: [G; IN_447], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_422], ExecError> { +) -> Result<[G; OUT_447], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 * __v_4); match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_422] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_421(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; @@ -38176,27 +40034,27 @@ fn aiur_fn_422( 0u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_422] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_422] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_422] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[422].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_447] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38207,48 +40065,48 @@ fn aiur_fn_422( }) } -const INPUT_SIZE_423: usize = 3; -const IN_423: usize = 3; -const OUT_423: usize = 1; -fn aiur_fn_423( - inp: [G; IN_423], +const INPUT_SIZE_448: usize = 3; +const IN_448: usize = 3; +const OUT_448: usize = 1; +fn aiur_fn_448( + inp: [G; IN_448], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_423], ExecError> { +) -> Result<[G; OUT_448], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_423] = [__v_4]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_4]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_423] = [__v_4]; - if let Some(result) = record.function_queries[423].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_448] = [__v_4]; + if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_424: usize = 3; -const IN_424: usize = 3; -const OUT_424: usize = 1; -fn aiur_fn_424( - inp: [G; IN_424], +const INPUT_SIZE_449: usize = 3; +const IN_449: usize = 3; +const OUT_449: usize = 1; +fn aiur_fn_449( + inp: [G; IN_449], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_424], ExecError> { +) -> Result<[G; OUT_449], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38262,48 +40120,48 @@ fn aiur_fn_424( 7u64 => { match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_216(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_228(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_424] = [__v_9]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_9]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_424] = [__v_7]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_7]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_424] = [__v_7]; - if let Some(result) = record.function_queries[424].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_449] = [__v_7]; + if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_425: usize = 3; -const IN_425: usize = 3; -const OUT_425: usize = 1; -fn aiur_fn_425( - inp: [G; IN_425], +const INPUT_SIZE_450: usize = 3; +const IN_450: usize = 3; +const OUT_450: usize = 1; +fn aiur_fn_450( + inp: [G; IN_450], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_425], ExecError> { +) -> Result<[G; OUT_450], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() { 1u64 => { @@ -38311,7 +40169,7 @@ fn aiur_fn_425( break '__mc_0 [__v_4]; }, _ => { - let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -38321,71 +40179,71 @@ fn aiur_fn_425( match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_425] = [__v_5]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_5]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_426(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_451(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_425] = [__v_5]; - if let Some(result) = record.function_queries[425].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_450] = [__v_5]; + if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_426: usize = 3; -const IN_426: usize = 3; -const OUT_426: usize = 1; -fn aiur_fn_426( - inp: [G; IN_426], +const INPUT_SIZE_451: usize = 3; +const IN_451: usize = 3; +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_426], ExecError> { +) -> Result<[G; OUT_451], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_395(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_420(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_426] = [__v_6]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_6]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_426] = [__v_7]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_7]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_426] = [__v_8]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_8]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_427(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_426] = [__v_8]; - if let Some(result) = record.function_queries[426].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_451] = [__v_8]; + if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38396,58 +40254,58 @@ fn aiur_fn_426( }) } -const INPUT_SIZE_427: usize = 5; -const IN_427: usize = 5; -const OUT_427: usize = 1; -fn aiur_fn_427( - inp: [G; IN_427], +const INPUT_SIZE_452: usize = 5; +const IN_452: usize = 5; +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_427], ExecError> { +) -> Result<[G; OUT_452], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_427] = [__v_8]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_8]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_428(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_427] = [__v_9]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_9]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_427] = [__v_10]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_10]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_429(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_427] = [__v_10]; - if let Some(result) = record.function_queries[427].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_452] = [__v_10]; + if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38458,15 +40316,15 @@ fn aiur_fn_427( }) } -const INPUT_SIZE_428: usize = 3; -const IN_428: usize = 3; -const OUT_428: usize = 1; -fn aiur_fn_428( - inp: [G; IN_428], +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_428], ExecError> { +) -> Result<[G; OUT_453], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38485,16 +40343,16 @@ fn aiur_fn_428( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_11]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_11]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_428] = [__v_11]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_11]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38507,30 +40365,30 @@ fn aiur_fn_428( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_14]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_14]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_428] = [__v_12]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_12]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_428] = [__v_11]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_11]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38543,53 +40401,53 @@ fn aiur_fn_428( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_428] = [__v_14]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_14]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_428] = [__v_12]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_12]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_428] = [__v_11]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_11]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_428] = [__v_7]; - if let Some(result) = record.function_queries[428].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_453] = [__v_7]; + if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_429: usize = 5; -const IN_429: usize = 5; -const OUT_429: usize = 1; -fn aiur_fn_429( - inp: [G; IN_429], +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_429], ExecError> { +) -> Result<[G; OUT_454], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38600,78 +40458,78 @@ fn aiur_fn_429( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_429] = [__v_6]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_6]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_429] = [__v_7]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_7]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_429] = [__v_8]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_8]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_429] = [__v_9]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_9]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_429] = [__v_10]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_10]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_429] = [__v_11]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_11]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(16); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; match __v_13.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __ret: [G; OUT_429] = [__v_16]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_16]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_430(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_429] = [__v_16]; - if let Some(result) = record.function_queries[429].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_454] = [__v_16]; + if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38690,15 +40548,15 @@ fn aiur_fn_429( }) } -const INPUT_SIZE_430: usize = 5; -const IN_430: usize = 5; -const OUT_430: usize = 1; -fn aiur_fn_430( - inp: [G; IN_430], +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_430], ExecError> { +) -> Result<[G; OUT_455], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38706,36 +40564,260 @@ fn aiur_fn_430( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = G::from_u64(8); - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_430] = [__v_8]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_455] = [__v_8]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_430] = [__v_8]; - if let Some(result) = record.function_queries[430].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_9]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_455] = [__v_9]; + if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_456: usize = 3; +const IN_456: usize = 3; +const OUT_456: usize = 1; +fn aiur_fn_456( + inp: [G; IN_456], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_456], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __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_456] = [__v_8]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = (__v_8 - __v_9); + match __v_10.as_canonical_u64() { + 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_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + match __v_11.as_canonical_u64() { + 8u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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() { + 8u64 => { + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = (__v_13 - __v_17); + let __v_21: G = G::from_bool((__v_20 == G::ZERO)); + let __v_22: G = (__v_14 - __v_18); + let __v_23: G = G::from_bool((__v_22 == G::ZERO)); + let __v_24: G = (__v_21 * __v_23); + let __v_25: G = (__v_19 * __v_24); + match __v_25.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __ret: [G; OUT_456] = [__v_26]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_26]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + let __v_19: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_19]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_15]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_11]; + if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_457: usize = 3; +const IN_457: usize = 3; +const OUT_457: usize = 1; +fn aiur_fn_457( + inp: [G; IN_457], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 = G::from_u64(8); + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_457] = [__v_6]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, + _ => { + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_457] = [__v_7]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_457] = [__v_7]; + if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, } }) } -const INPUT_SIZE_431: usize = 4; -const IN_431: usize = 4; -const OUT_431: usize = 2; -fn aiur_fn_431( - inp: [G; IN_431], +const INPUT_SIZE_458: usize = 3; +const IN_458: usize = 3; +const OUT_458: usize = 1; +fn aiur_fn_458( + inp: [G; IN_458], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_431], ExecError> { +) -> Result<[G; OUT_458], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(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() { + 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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_458] = [__v_12]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_458] = [__v_12]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_458] = [__v_11]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }, + _ => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_458] = [__v_7]; + if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_459: usize = 4; +const IN_459: usize = 4; +const OUT_459: usize = 2; +fn aiur_fn_459( + inp: [G; IN_459], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_459], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -38745,8 +40827,8 @@ fn aiur_fn_431( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_431] = [__v_5, __v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_5, __v_2]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -38768,24 +40850,24 @@ fn aiur_fn_431( match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_431] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_431] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38798,18 +40880,18 @@ fn aiur_fn_431( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_431] = [__v_13, __v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13, __v_2]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38826,28 +40908,28 @@ fn aiur_fn_431( let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_431] = [__v_14, __v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_14, __v_2]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38860,32 +40942,32 @@ fn aiur_fn_431( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_431] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38898,34 +40980,34 @@ fn aiur_fn_431( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_431] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38938,34 +41020,34 @@ fn aiur_fn_431( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; match __v_13.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_431] = [__v_15, __v_14]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_15, __v_14]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -38978,18 +41060,18 @@ fn aiur_fn_431( let __v_12: G = __loaded[3]; match __v_9.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_431] = [__v_13, __v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13, __v_2]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39009,47 +41091,47 @@ fn aiur_fn_431( let __v_14: G = (__v_7 - __v_11); match __v_14.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_431] = [__v_15, __v_2]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_15, __v_2]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_431] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[431].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_459] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39058,15 +41140,15 @@ fn aiur_fn_431( }) } -const INPUT_SIZE_432: usize = 4; -const IN_432: usize = 4; -const OUT_432: usize = 2; -fn aiur_fn_432( - inp: [G; IN_432], +const INPUT_SIZE_460: usize = 4; +const IN_460: usize = 4; +const OUT_460: usize = 2; +fn aiur_fn_460( + inp: [G; IN_460], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_432], ExecError> { +) -> Result<[G; OUT_460], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39076,54 +41158,54 @@ fn aiur_fn_432( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_432] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(1); let __v_5: G = (__v_2 - __v_4); - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 - __v_7); match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_432] = [__v_9, __v_5]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_9, __v_5]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_432] = [__v_10, __v_5]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_10, __v_5]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(8); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; match __v_12.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_432] = [__v_15, __v_5]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_15, __v_5]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_432] = [__v_15, __v_16]; - if let Some(result) = record.function_queries[432].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_460] = [__v_15, __v_16]; + if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39136,96 +41218,96 @@ fn aiur_fn_432( }) } -const INPUT_SIZE_433: usize = 3; -const IN_433: usize = 3; -const OUT_433: usize = 1; -fn aiur_fn_433( - inp: [G; IN_433], +const INPUT_SIZE_461: usize = 3; +const IN_461: usize = 3; +const OUT_461: usize = 1; +fn aiur_fn_461( + inp: [G; IN_461], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_433], ExecError> { +) -> Result<[G; OUT_461], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_3 - __v_4); match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_433] = [__v_6]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_6]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_440(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_433] = [__v_7]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_7]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_433] = [__v_8]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_8]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_433] = [__v_9]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_9]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_434(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_433] = [__v_10]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_10]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_433] = [__v_11]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_11]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_437(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_433] = [__v_13]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_13]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_443(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_433] = [__v_13]; - if let Some(result) = record.function_queries[433].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_461] = [__v_13]; + if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39244,15 +41326,15 @@ fn aiur_fn_433( }) } -const INPUT_SIZE_434: usize = 3; -const IN_434: usize = 3; -const OUT_434: usize = 1; -fn aiur_fn_434( - inp: [G; IN_434], +const INPUT_SIZE_462: usize = 3; +const IN_462: usize = 3; +const OUT_462: usize = 1; +fn aiur_fn_462( + inp: [G; IN_462], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_434], ExecError> { +) -> Result<[G; OUT_462], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39267,7 +41349,7 @@ fn aiur_fn_434( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -39284,13 +41366,13 @@ fn aiur_fn_434( let __v_21: G = __loaded[11]; match __v_10.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_16 + __v_17); let __v_24: G = (__v_22 - __v_23); match __v_24.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_26: G = __loaded[0]; @@ -39315,42 +41397,42 @@ fn aiur_fn_434( match __v_42.as_canonical_u64() { 0u64 => { let __v_43: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_43]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_43]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_386(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; match __v_44.as_canonical_u64() { 1u64 => { let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_45]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_45]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; match __v_47.as_canonical_u64() { 0u64 => { let __v_48: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_48]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_48]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_434] = [__v_49]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_49]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39361,47 +41443,47 @@ fn aiur_fn_434( }, _ => { let __v_38: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_38]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_38]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_25]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_25]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_22]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_22]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_434] = [__v_9]; - if let Some(result) = record.function_queries[434].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_462] = [__v_9]; + if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_435: usize = 7; -const IN_435: usize = 7; -const OUT_435: usize = 1; -fn aiur_fn_435( - inp: [G; IN_435], +const INPUT_SIZE_463: usize = 7; +const IN_463: usize = 7; +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_435], ExecError> { +) -> Result<[G; OUT_463], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39414,32 +41496,32 @@ fn aiur_fn_435( match __v_7.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_435] = [__v_8]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_8]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(8); let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_435] = [__v_13]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_13]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = (__v_5 + __v_13); - let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_435(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_435] = [__v_15]; - if let Some(result) = record.function_queries[435].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_463] = [__v_15]; + if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39448,19 +41530,19 @@ fn aiur_fn_435( }) } -const INPUT_SIZE_436: usize = 2; -const IN_436: usize = 2; -const OUT_436: usize = 1; -fn aiur_fn_436( - inp: [G; IN_436], +const INPUT_SIZE_464: usize = 2; +const IN_464: usize = 2; +const OUT_464: usize = 1; +fn aiur_fn_464( + inp: [G; IN_464], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_436], ExecError> { +) -> Result<[G; OUT_464], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -39487,21 +41569,21 @@ fn aiur_fn_436( let __v_24: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_436] = [__v_25]; - if let Some(result) = record.function_queries[436].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_464] = [__v_25]; + if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_437: usize = 3; -const IN_437: usize = 3; -const OUT_437: usize = 1; -fn aiur_fn_437( - inp: [G; IN_437], +const INPUT_SIZE_465: usize = 3; +const IN_465: usize = 3; +const OUT_465: usize = 1; +fn aiur_fn_465( + inp: [G; IN_465], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_437], ExecError> { +) -> Result<[G; OUT_465], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39521,15 +41603,15 @@ fn aiur_fn_437( match __v_7.as_canonical_u64() { 4u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_11]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_11]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_11]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_11]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39542,16 +41624,16 @@ fn aiur_fn_437( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_437] = [__v_11]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_11]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_437] = [__v_11]; - if let Some(result) = record.function_queries[437].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_465] = [__v_11]; + if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39560,54 +41642,54 @@ fn aiur_fn_437( }) } -const INPUT_SIZE_438: usize = 3; -const IN_438: usize = 3; -const OUT_438: usize = 1; -fn aiur_fn_438( - inp: [G; IN_438], +const INPUT_SIZE_466: usize = 3; +const IN_466: usize = 3; +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_438], ExecError> { +) -> Result<[G; OUT_466], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_438] = [__v_6]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_6]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_438] = [__v_7]; - if let Some(result) = record.function_queries[438].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_466] = [__v_7]; + if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_439: usize = 1; -const IN_439: usize = 1; -const OUT_439: usize = 1; -fn aiur_fn_439( - inp: [G; IN_439], +const INPUT_SIZE_467: usize = 1; +const IN_467: usize = 1; +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_439], ExecError> { +) -> Result<[G; OUT_467], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; @@ -39620,7 +41702,7 @@ fn aiur_fn_439( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -39644,7 +41726,7 @@ fn aiur_fn_439( match __v_21.as_canonical_u64() { 0u64 => { let __v_22: G = G::from_u64(0); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_24: G = __loaded[0]; @@ -39664,114 +41746,114 @@ fn aiur_fn_439( match __v_31.as_canonical_u64() { 0u64 => { let __v_36: G = G::from_u64(1); - let __ret: [G; OUT_439] = [__v_36]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_467] = [__v_36]; + if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_36]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_467] = [__v_36]; + if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_36: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_36]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_467] = [__v_36]; + if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_22: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_22]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_467] = [__v_22]; + if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_20]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_467] = [__v_20]; + if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_20]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_467] = [__v_20]; + if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_439] = [__v_7]; - if let Some(result) = record.function_queries[439].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_467] = [__v_7]; + if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_440: usize = 3; -const IN_440: usize = 3; -const OUT_440: usize = 1; -fn aiur_fn_440( - inp: [G; IN_440], +const INPUT_SIZE_468: usize = 3; +const IN_468: usize = 3; +const OUT_468: usize = 1; +fn aiur_fn_468( + inp: [G; IN_468], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_440], ExecError> { +) -> Result<[G; OUT_468], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_442(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_440] = [__v_5]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_5]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_440] = [__v_6]; - if let Some(result) = record.function_queries[440].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_468] = [__v_6]; + if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_441: usize = 4; -const IN_441: usize = 4; -const OUT_441: usize = 1; -fn aiur_fn_441( - inp: [G; IN_441], +const INPUT_SIZE_469: usize = 4; +const IN_469: usize = 4; +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_441], ExecError> { +) -> Result<[G; OUT_469], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -39780,19 +41862,19 @@ fn aiur_fn_441( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_441] = [__v_11]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_11]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(0); @@ -39803,39 +41885,39 @@ fn aiur_fn_441( let __v_20: G = { let __values: [G; 4] = [__v_18, __v_13, __v_17, __v_19]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 3] = [__v_21, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_441] = [__v_23]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_23]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_441] = [__v_10]; - if let Some(result) = record.function_queries[441].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_469] = [__v_10]; + if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_442: usize = 2; -const IN_442: usize = 2; -const OUT_442: usize = 1; -fn aiur_fn_442( - inp: [G; IN_442], +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_442], ExecError> { +) -> Result<[G; OUT_470], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_408(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_433(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -39851,58 +41933,58 @@ fn aiur_fn_442( match __v_8.as_canonical_u64() { 0u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_442] = [__v_11]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_470] = [__v_11]; + if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_11]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_470] = [__v_11]; + if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_442] = [__v_8]; - if let Some(result) = record.function_queries[442].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_470] = [__v_8]; + if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_443: usize = 3; -const IN_443: usize = 3; -const OUT_443: usize = 1; -fn aiur_fn_443( - inp: [G; IN_443], +const INPUT_SIZE_471: usize = 3; +const IN_471: usize = 3; +const OUT_471: usize = 1; +fn aiur_fn_471( + inp: [G; IN_471], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_443], ExecError> { +) -> Result<[G; OUT_471], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_443] = [__v_3]; - if let Some(result) = record.function_queries[443].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_471] = [__v_3]; + if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_444: usize = 3; -const IN_444: usize = 3; -const OUT_444: usize = 1; -fn aiur_fn_444( - inp: [G; IN_444], +const INPUT_SIZE_472: usize = 3; +const IN_472: usize = 3; +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_444], ExecError> { +) -> Result<[G; OUT_472], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -39925,22 +42007,22 @@ fn aiur_fn_444( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_444] = [__v_12]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_12]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_12]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_12]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_11]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39953,16 +42035,16 @@ fn aiur_fn_444( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_11]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_11]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -39979,26 +42061,26 @@ fn aiur_fn_444( let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_413(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_438(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_12]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_12]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_12]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_12]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_11]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40011,31 +42093,31 @@ fn aiur_fn_444( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_12]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_12]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_13]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_13]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_444] = [__v_13]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_13]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40043,10 +42125,10 @@ fn aiur_fn_444( } }, _ => { - let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_457(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_11]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40059,31 +42141,31 @@ fn aiur_fn_444( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_12]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_12]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_14]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_14]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_441(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_11]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40096,38 +42178,38 @@ fn aiur_fn_444( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_12]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_12]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_14]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_14]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_11]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_7]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_7]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { @@ -40138,28 +42220,28 @@ fn aiur_fn_444( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_11]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_375(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_400(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = (__v_11 - __v_0); match __v_12.as_canonical_u64() { 0u64 => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_13]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_13]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_444(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_13]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_13]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40181,32 +42263,32 @@ fn aiur_fn_444( let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_444] = [__v_13]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_13]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_13]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_13]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_12]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_12]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_444] = [__v_11]; - if let Some(result) = record.function_queries[444].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_472] = [__v_11]; + if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40218,15 +42300,15 @@ fn aiur_fn_444( }) } -const INPUT_SIZE_445: usize = 4; -const IN_445: usize = 4; -const OUT_445: usize = 3; -fn aiur_fn_445( - inp: [G; IN_445], +const INPUT_SIZE_473: usize = 4; +const IN_473: usize = 4; +const OUT_473: usize = 3; +fn aiur_fn_473( + inp: [G; IN_473], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_445], ExecError> { +) -> Result<[G; OUT_473], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40235,8 +42317,8 @@ fn aiur_fn_445( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_445] = [__v_4, __v_0, __v_1]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_4, __v_0, __v_1]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -40244,46 +42326,46 @@ fn aiur_fn_445( match __v_4.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_445] = [__v_5, __v_0, __v_1]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_5, __v_0, __v_1]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_422(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_445] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; match __v_8.as_canonical_u64() { 1u64 => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_447(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_445] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_451(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_445] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40291,21 +42373,21 @@ fn aiur_fn_445( _ => { match __v_10.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_452(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_445] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_453(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __ret: [G; OUT_445] = [__v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[445].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_473] = [__v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40320,15 +42402,15 @@ fn aiur_fn_445( }) } -const INPUT_SIZE_446: usize = 12; -const IN_446: usize = 12; -const OUT_446: usize = 1; -fn aiur_fn_446( - inp: [G; IN_446], +const INPUT_SIZE_474: usize = 12; +const IN_474: usize = 12; +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_446], ExecError> { +) -> Result<[G; OUT_474], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40344,29 +42426,29 @@ fn aiur_fn_446( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_446] = [__v_5]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_5]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_446] = [__v_12]; - if let Some(result) = record.function_queries[446].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_474] = [__v_12]; + if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_447: usize = 6; -const IN_447: usize = 6; -const OUT_447: usize = 3; -fn aiur_fn_447( - inp: [G; IN_447], +const INPUT_SIZE_475: usize = 6; +const IN_475: usize = 6; +const OUT_475: usize = 3; +fn aiur_fn_475( + inp: [G; IN_475], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_447], ExecError> { +) -> Result<[G; OUT_475], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40374,7 +42456,7 @@ fn aiur_fn_447( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -40389,7 +42471,7 @@ fn aiur_fn_447( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -40404,26 +42486,26 @@ fn aiur_fn_447( let __v_29: G = __loaded[9]; let __v_30: G = __loaded[10]; let __v_31: G = __loaded[11]; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__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[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__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[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_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[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_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[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; match __v_32.as_canonical_u64() { 0u64 => { match __v_33.as_canonical_u64() { 0u64 => { let __v_34: G = G::from_u64(0); - let __ret: [G; OUT_447] = [__v_34, __v_2, __v_3]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_34, __v_2, __v_3]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __ret: [G; OUT_447] = [__v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40431,49 +42513,49 @@ fn aiur_fn_447( _ => { match __v_33.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; - let __ret: [G; OUT_447] = [__v_34, __v_35, __v_36]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_34, __v_35, __v_36]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__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[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__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[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_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[446].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_446(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_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[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_36.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_448(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; - let __ret: [G; OUT_447] = [__v_37, __v_38, __v_39]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_37, __v_38, __v_39]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_37.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_449(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; - let __ret: [G; OUT_447] = [__v_38, __v_39, __v_40]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_38, __v_39, __v_40]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_450(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; - let __ret: [G; OUT_447] = [__v_38, __v_39, __v_40]; - if let Some(result) = record.function_queries[447].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_475] = [__v_38, __v_39, __v_40]; + if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40486,176 +42568,176 @@ fn aiur_fn_447( }) } -const INPUT_SIZE_448: usize = 4; -const IN_448: usize = 4; -const OUT_448: usize = 3; -fn aiur_fn_448( - inp: [G; IN_448], +const INPUT_SIZE_476: usize = 4; +const IN_476: usize = 4; +const OUT_476: usize = 3; +fn aiur_fn_476( + inp: [G; IN_476], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_448], ExecError> { +) -> Result<[G; OUT_476], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_448] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_448] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[448].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_476] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_449: usize = 4; -const IN_449: usize = 4; -const OUT_449: usize = 3; -fn aiur_fn_449( - inp: [G; IN_449], +const INPUT_SIZE_477: usize = 4; +const IN_477: usize = 4; +const OUT_477: usize = 3; +fn aiur_fn_477( + inp: [G; IN_477], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_449], ExecError> { +) -> Result<[G; OUT_477], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_449] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_449] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[449].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[449].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_477] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_450: usize = 4; -const IN_450: usize = 4; -const OUT_450: usize = 3; -fn aiur_fn_450( - inp: [G; IN_450], +const INPUT_SIZE_478: usize = 4; +const IN_478: usize = 4; +const OUT_478: usize = 3; +fn aiur_fn_478( + inp: [G; IN_478], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_450], ExecError> { +) -> Result<[G; OUT_478], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_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_445] = { let __args: [G; IN_445] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; - let __ret: [G; OUT_450] = [__v_12, __v_13, __v_14]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_12, __v_13, __v_14]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_450] = [__v_8, __v_0, __v_1]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_8, __v_0, __v_1]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_450] = [__v_6, __v_0, __v_1]; - if let Some(result) = record.function_queries[450].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_478] = [__v_6, __v_0, __v_1]; + if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_451: usize = 5; -const IN_451: usize = 5; -const OUT_451: usize = 3; -fn aiur_fn_451( - inp: [G; IN_451], +const INPUT_SIZE_479: usize = 5; +const IN_479: usize = 5; +const OUT_479: usize = 3; +fn aiur_fn_479( + inp: [G; IN_479], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_451], ExecError> { +) -> Result<[G; OUT_479], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_451] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -40670,35 +42752,35 @@ fn aiur_fn_451( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_451] = [__v_21, __v_1, __v_2]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_21, __v_1, __v_2]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; - let __ret: [G; OUT_451] = [__v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_451] = [__v_23, __v_1, __v_2]; - if let Some(result) = record.function_queries[451].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_479] = [__v_23, __v_1, __v_2]; + if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40709,38 +42791,38 @@ fn aiur_fn_451( }) } -const INPUT_SIZE_452: usize = 5; -const IN_452: usize = 5; -const OUT_452: usize = 3; -fn aiur_fn_452( - inp: [G; IN_452], +const INPUT_SIZE_480: usize = 5; +const IN_480: usize = 5; +const OUT_480: usize = 3; +fn aiur_fn_480( + inp: [G; IN_480], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_452], ExecError> { +) -> Result<[G; OUT_480], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 - __v_7); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = __r_arr[2]; - let __ret: [G; OUT_452] = [__v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -40755,35 +42837,35 @@ fn aiur_fn_452( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_454(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; match __v_20.as_canonical_u64() { 0u64 => { let __v_21: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_21, __v_1, __v_2]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_21, __v_1, __v_2]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; match __v_21.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(1); let __v_24: G = (__v_3 - __v_23); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; let __v_27: G = __r_arr[2]; - let __ret: [G; OUT_452] = [__v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_452] = [__v_23, __v_1, __v_2]; - if let Some(result) = record.function_queries[452].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_480] = [__v_23, __v_1, __v_2]; + if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40794,24 +42876,24 @@ fn aiur_fn_452( }) } -const INPUT_SIZE_453: usize = 4; -const IN_453: usize = 4; -const OUT_453: usize = 3; -fn aiur_fn_453( - inp: [G; IN_453], +const INPUT_SIZE_481: usize = 4; +const IN_481: usize = 4; +const OUT_481: usize = 3; +fn aiur_fn_481( + inp: [G; IN_481], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_453], ExecError> { +) -> Result<[G; OUT_481], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_455(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_4.as_canonical_u64() { @@ -40820,23 +42902,23 @@ fn aiur_fn_453( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_453] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_453] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40846,18 +42928,18 @@ fn aiur_fn_453( 1u64 => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 - __v_8); - let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_445(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; - let __ret: [G; OUT_453] = [__v_10, __v_11, __v_12]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_10, __v_11, __v_12]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_453] = [__v_8, __v_0, __v_1]; - if let Some(result) = record.function_queries[453].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_481] = [__v_8, __v_0, __v_1]; + if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -40866,15 +42948,15 @@ fn aiur_fn_453( }) } -const INPUT_SIZE_454: usize = 12; -const IN_454: usize = 12; -const OUT_454: usize = 1; -fn aiur_fn_454( - inp: [G; IN_454], +const INPUT_SIZE_482: usize = 12; +const IN_482: usize = 12; +const OUT_482: usize = 1; +fn aiur_fn_482( + inp: [G; IN_482], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_454], ExecError> { +) -> Result<[G; OUT_482], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40891,35 +42973,35 @@ fn aiur_fn_454( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_12]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_482] = [__v_12]; + if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_454] = [__v_12]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_482] = [__v_12]; + if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_454] = [__v_12]; - if let Some(result) = record.function_queries[454].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_482] = [__v_12]; + if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_455: usize = 2; -const IN_455: usize = 2; -const OUT_455: usize = 2; -fn aiur_fn_455( - inp: [G; IN_455], +const INPUT_SIZE_483: usize = 2; +const IN_483: usize = 2; +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_455], ExecError> { +) -> Result<[G; OUT_483], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -40933,7 +43015,7 @@ fn aiur_fn_455( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -40945,7 +43027,7 @@ fn aiur_fn_455( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -40953,47 +43035,47 @@ fn aiur_fn_455( let __v_17: G = G::from_u64(8); let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_455] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_17, __v_0]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_17, __v_0]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_455] = [__v_15, __v_8]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_15, __v_8]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_455] = [__v_8, __v_0]; - if let Some(result) = record.function_queries[455].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_483] = [__v_8, __v_0]; + if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_456: usize = 1; -const IN_456: usize = 1; -const OUT_456: usize = 2; -fn aiur_fn_456( - inp: [G; IN_456], +const INPUT_SIZE_484: usize = 1; +const IN_484: usize = 1; +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_456], ExecError> { +) -> Result<[G; OUT_484], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; @@ -41006,7 +43088,7 @@ fn aiur_fn_456( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -41023,79 +43105,79 @@ fn aiur_fn_456( let __v_19: G = __loaded[11]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_456] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_456] = [__v_21, __v_22]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_21, __v_22]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __ret: [G; OUT_456] = [__v_20, __v_0]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_20, __v_0]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_456] = [__v_7, __v_0]; - if let Some(result) = record.function_queries[456].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_484] = [__v_7, __v_0]; + if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_457: usize = 3; -const IN_457: usize = 3; -const OUT_457: usize = 1; -fn aiur_fn_457( - inp: [G; IN_457], +const INPUT_SIZE_485: usize = 3; +const IN_485: usize = 3; +const OUT_485: usize = 1; +fn aiur_fn_485( + inp: [G; IN_485], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_457], ExecError> { +) -> Result<[G; OUT_485], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_458(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_4.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_457] = [__v_7]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_7]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_6.as_canonical_u64() { 0u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_457] = [__v_7]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_7]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -41110,7 +43192,7 @@ fn aiur_fn_457( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_21: G = __loaded[0]; @@ -41125,27 +43207,27 @@ fn aiur_fn_457( let __v_30: G = __loaded[9]; let __v_31: G = __loaded[10]; let __v_32: G = __loaded[11]; - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_459(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; match __v_33.as_canonical_u64() { 1u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_457] = [__v_37]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_37]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_457] = [__v_37]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_37]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41153,16 +43235,16 @@ fn aiur_fn_457( 0u64 => { match __v_35.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_457] = [__v_37]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_37]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_457] = [__v_37]; - if let Some(result) = record.function_queries[457].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_485] = [__v_37]; + if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41178,15 +43260,15 @@ fn aiur_fn_457( }) } -const INPUT_SIZE_458: usize = 1; -const IN_458: usize = 1; -const OUT_458: usize = 2; -fn aiur_fn_458( - inp: [G; IN_458], +const INPUT_SIZE_486: usize = 1; +const IN_486: usize = 1; +const OUT_486: usize = 2; +fn aiur_fn_486( + inp: [G; IN_486], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_458], ExecError> { +) -> Result<[G; OUT_486], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; @@ -41200,8 +43282,8 @@ fn aiur_fn_458( match __v_3.as_canonical_u64() { 2u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_458] = [__v_4, __v_7]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_4, __v_7]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -41239,23 +43321,23 @@ fn aiur_fn_458( let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_40: G = G::from_u64(0); - let __ret: [G; OUT_458] = [__v_39, __v_40]; - if let Some(result) = record.function_queries[458].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_486] = [__v_39, __v_40]; + if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_459: usize = 14; -const IN_459: usize = 14; -const OUT_459: usize = 2; -fn aiur_fn_459( - inp: [G; IN_459], +const INPUT_SIZE_487: usize = 14; +const IN_487: usize = 14; +const OUT_487: usize = 2; +fn aiur_fn_487( + inp: [G; IN_487], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_459], ExecError> { +) -> Result<[G; OUT_487], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41273,154 +43355,154 @@ fn aiur_fn_459( let __v_13: G = inp[13]; match __v_1.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_459] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_456(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { 1u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_399(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_15, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_424(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_459] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_459] = [__v_14, __v_0]; - if let Some(result) = record.function_queries[459].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_487] = [__v_14, __v_0]; + if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_460: usize = 2; -const IN_460: usize = 2; -const OUT_460: usize = 1; -fn aiur_fn_460( - inp: [G; IN_460], +const INPUT_SIZE_488: usize = 2; +const IN_488: usize = 2; +const OUT_488: usize = 1; +fn aiur_fn_488( + inp: [G; IN_488], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_460], ExecError> { +) -> Result<[G; OUT_488], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_460] = [__v_6]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_488] = [__v_6]; + if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_461(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_489(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_460] = [__v_3]; - if let Some(result) = record.function_queries[460].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_488] = [__v_3]; + if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_461: usize = 3; -const IN_461: usize = 3; -const OUT_461: usize = 1; -fn aiur_fn_461( - inp: [G; IN_461], +const INPUT_SIZE_489: usize = 3; +const IN_489: usize = 3; +const OUT_489: usize = 1; +fn aiur_fn_489( + inp: [G; IN_489], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_461], ExecError> { +) -> Result<[G; OUT_489], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_355(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_345(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_461] = [__v_8]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_8]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_2 - __v_6); - let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_354(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_462(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_461] = [__v_14]; - if let Some(result) = record.function_queries[461].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_489] = [__v_14]; + if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_462: usize = 2; -const IN_462: usize = 2; -const OUT_462: usize = 1; -fn aiur_fn_462( - inp: [G; IN_462], +const INPUT_SIZE_490: usize = 2; +const IN_490: usize = 2; +const OUT_490: usize = 1; +fn aiur_fn_490( + inp: [G; IN_490], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_462], ExecError> { +) -> Result<[G; OUT_490], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41431,15 +43513,15 @@ fn aiur_fn_462( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_3 + __v_7); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_462] = [__v_10]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_10]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -41447,16 +43529,16 @@ fn aiur_fn_462( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_311(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_333(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_6, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_462] = [__v_12]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_12]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_7: G = __loaded[0]; @@ -41471,91 +43553,91 @@ fn aiur_fn_462( let __v_16: G = __loaded[9]; let __v_17: G = __loaded[10]; let __v_18: G = __loaded[11]; - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__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[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__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[407].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_407(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__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[432].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_432(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_20 != __v_19) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_462] = [__v_22]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_22]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_462] = [__v_12]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_12]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(5); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_10, __v_3, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_462] = [__v_12]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_12]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 3] = [__v_7, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[310].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_310(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_332(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_462] = [__v_13]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_13]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_5, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_462] = [__v_9]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_9]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_464(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_492(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_462] = [__v_6]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_6]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_470(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_462] = [__v_6]; - if let Some(result) = record.function_queries[462].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_490] = [__v_6]; + if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -41565,15 +43647,15 @@ fn aiur_fn_462( }) } -const INPUT_SIZE_463: usize = 4; -const IN_463: usize = 4; -const OUT_463: usize = 1; -fn aiur_fn_463( - inp: [G; IN_463], +const INPUT_SIZE_491: usize = 4; +const IN_491: usize = 4; +const OUT_491: usize = 1; +fn aiur_fn_491( + inp: [G; IN_491], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_463], ExecError> { +) -> Result<[G; OUT_491], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41585,20 +43667,20 @@ fn aiur_fn_463( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_463] = [__v_0]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_491] = [__v_0]; + if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_463] = [__v_9]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_491] = [__v_9]; + if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41611,7 +43693,7 @@ fn aiur_fn_463( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() { 0u64 => { @@ -41619,24 +43701,24 @@ fn aiur_fn_463( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_0 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_463] = [__v_15]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_491] = [__v_15]; + if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() { 0u64 => { @@ -41644,14 +43726,14 @@ fn aiur_fn_463( }, _ => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; break '__mc_1 [__v_13]; }, } }; let __v_12: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_14: G = __loaded[0]; @@ -41660,16 +43742,16 @@ fn aiur_fn_463( let __v_17: G = __loaded[3]; match __v_14.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_463(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_463] = [__v_23]; - if let Some(result) = record.function_queries[463].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_491] = [__v_23]; + if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -41686,43 +43768,43 @@ fn aiur_fn_463( }) } -const INPUT_SIZE_464: usize = 2; -const IN_464: usize = 2; -const OUT_464: usize = 1; -fn aiur_fn_464( - inp: [G; IN_464], +const INPUT_SIZE_492: usize = 2; +const IN_492: usize = 2; +const OUT_492: usize = 1; +fn aiur_fn_492( + inp: [G; IN_492], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_464], ExecError> { +) -> Result<[G; OUT_492], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(2); - 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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_357(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_382(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_464] = [__v_8]; - if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_492] = [__v_8]; + if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(2); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_2, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_464] = [__v_8]; - if let Some(result) = record.function_queries[464].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_492] = [__v_8]; + if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -41732,23 +43814,23 @@ fn aiur_fn_464( }) } -const INPUT_SIZE_465: usize = 4; -const IN_465: usize = 4; -const OUT_465: usize = 1; -fn aiur_fn_465( - inp: [G; IN_465], +const INPUT_SIZE_493: usize = 4; +const IN_493: usize = 4; +const OUT_493: usize = 1; +fn aiur_fn_493( + inp: [G; IN_493], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_465], ExecError> { +) -> Result<[G; OUT_493], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -41760,10 +43842,10 @@ fn aiur_fn_465( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_465] = [__v_13]; - if let Some(result) = record.function_queries[465].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_493] = [__v_13]; + if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -41773,29 +43855,29 @@ fn aiur_fn_465( }) } -const INPUT_SIZE_466: usize = 3; -const IN_466: usize = 3; -const OUT_466: usize = 1; -fn aiur_fn_466( - inp: [G; IN_466], +const INPUT_SIZE_494: usize = 3; +const IN_494: usize = 3; +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_466], ExecError> { +) -> Result<[G; OUT_494], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_466] = [__v_3]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_494] = [__v_3]; + if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -41808,15 +43890,15 @@ fn aiur_fn_466( let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_466(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_466] = [__v_12]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_494] = [__v_12]; + if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_466] = [__v_3]; - if let Some(result) = record.function_queries[466].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_494] = [__v_3]; + if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41825,54 +43907,54 @@ fn aiur_fn_466( }) } -const INPUT_SIZE_467: usize = 3; -const IN_467: usize = 3; -const OUT_467: usize = 0; -fn aiur_fn_467( - inp: [G; IN_467], +const INPUT_SIZE_495: usize = 3; +const IN_495: usize = 3; +const OUT_495: usize = 0; +fn aiur_fn_495( + inp: [G; IN_495], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_467], ExecError> { +) -> Result<[G; OUT_495], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_467] = []; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_495] = []; + if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("projection on a Prop structure: field is not a Prop".to_string()) }); } - let __ret: [G; OUT_467] = []; - if let Some(result) = record.function_queries[467].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_495] = []; + if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_468: usize = 4; -const IN_468: usize = 4; -const OUT_468: usize = 0; -fn aiur_fn_468( - inp: [G; IN_468], +const INPUT_SIZE_496: usize = 4; +const IN_496: usize = 4; +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_468], ExecError> { +) -> Result<[G; OUT_496], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41880,33 +43962,33 @@ fn aiur_fn_468( let __v_3: G = inp[3]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_468] = []; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_496] = []; + if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_468] = []; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_496] = []; + if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_319(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); if (__v_9 != __v_10) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("projection on a Prop structure: later fields depend on a data field".to_string()) }); } - let __ret: [G; OUT_468] = []; - if let Some(result) = record.function_queries[468].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_496] = []; + if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41915,15 +43997,15 @@ fn aiur_fn_468( }) } -const INPUT_SIZE_469: usize = 7; -const IN_469: usize = 7; -const OUT_469: usize = 1; -fn aiur_fn_469( - inp: [G; IN_469], +const INPUT_SIZE_497: usize = 7; +const IN_497: usize = 7; +const OUT_497: usize = 1; +fn aiur_fn_497( + inp: [G; IN_497], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_469], ExecError> { +) -> Result<[G; OUT_497], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -41942,24 +44024,24 @@ fn aiur_fn_469( let __v_11: G = (__v_1 - __v_2); match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_467(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_469] = [__v_8]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_495(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_497] = [__v_8]; + if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_468(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; let __v_12: G = G::from_u64(8); let __v_13: G = { let __values: [G; 4] = [__v_12, __v_3, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 + __v_16); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_469] = [__v_18]; - if let Some(result) = record.function_queries[469].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_497] = [__v_18]; + if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -41971,23 +44053,23 @@ fn aiur_fn_469( }) } -const INPUT_SIZE_470: usize = 4; -const IN_470: usize = 4; -const OUT_470: usize = 1; -fn aiur_fn_470( - inp: [G; IN_470], +const INPUT_SIZE_498: usize = 4; +const IN_498: usize = 4; +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_470], ExecError> { +) -> Result<[G; OUT_498], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -41999,7 +44081,7 @@ fn aiur_fn_470( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_13: G = __loaded[0]; @@ -42020,7 +44102,7 @@ fn aiur_fn_470( match __v_13.as_canonical_u64() { 5u64 => { let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_27: G = __loaded[0]; @@ -42041,18 +44123,18 @@ fn aiur_fn_470( } match __v_27.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_29, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_411(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_436(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = (__v_16 + __v_17); - let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_465(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(0); - let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_469(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __ret: [G; OUT_470] = [__v_45]; - if let Some(result) = record.function_queries[470].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_498] = [__v_45]; + if let Some(result) = record.function_queries[498].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -42072,21 +44154,21 @@ fn aiur_fn_470( }) } -const INPUT_SIZE_471: usize = 2; -const IN_471: usize = 2; -const OUT_471: usize = 1; -fn aiur_fn_471( - inp: [G; IN_471], +const INPUT_SIZE_499: usize = 2; +const IN_499: usize = 2; +const OUT_499: usize = 1; +fn aiur_fn_499( + inp: [G; IN_499], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_471], ExecError> { +) -> Result<[G; OUT_499], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -42095,8 +44177,8 @@ fn aiur_fn_471( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_471] = [__v_5]; - if let Some(result) = record.function_queries[471].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_499] = [__v_5]; + if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -42106,42 +44188,42 @@ fn aiur_fn_471( }) } -const INPUT_SIZE_472: usize = 3; -const IN_472: usize = 3; -const OUT_472: usize = 0; -fn aiur_fn_472( - inp: [G; IN_472], +const INPUT_SIZE_500: usize = 3; +const IN_500: usize = 3; +const OUT_500: usize = 0; +fn aiur_fn_500( + inp: [G; IN_500], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_472], ExecError> { +) -> Result<[G; OUT_500], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); if (__v_4 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("inferred type is not def-eq to the expected type".to_string()) }); } - let __ret: [G; OUT_472] = []; - if let Some(result) = record.function_queries[472].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_500] = []; + if let Some(result) = record.function_queries[500].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_473: usize = 0; -const IN_473: usize = 0; -const OUT_473: usize = 1; -fn aiur_fn_473( - inp: [G; IN_473], +const INPUT_SIZE_501: usize = 0; +const IN_501: usize = 0; +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_473], ExecError> { +) -> Result<[G; OUT_501], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(69); let __v_1: G = G::from_u64(96); @@ -42176,21 +44258,21 @@ fn aiur_fn_473( let __v_30: G = G::from_u64(47); let __v_31: G = G::from_u64(219); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_473] = [__v_32]; - if let Some(result) = record.function_queries[473].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_501] = [__v_32]; + if let Some(result) = record.function_queries[501].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_474: usize = 0; -const IN_474: usize = 0; -const OUT_474: usize = 1; -fn aiur_fn_474( - inp: [G; IN_474], +const INPUT_SIZE_502: usize = 0; +const IN_502: usize = 0; +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_474], ExecError> { +) -> Result<[G; OUT_502], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(163); let __v_1: G = G::from_u64(245); @@ -42225,21 +44307,21 @@ fn aiur_fn_474( let __v_30: G = G::from_u64(51); let __v_31: G = G::from_u64(118); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_474] = [__v_32]; - if let Some(result) = record.function_queries[474].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_502] = [__v_32]; + if let Some(result) = record.function_queries[502].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_475: usize = 0; -const IN_475: usize = 0; -const OUT_475: usize = 1; -fn aiur_fn_475( - inp: [G; IN_475], +const INPUT_SIZE_503: usize = 0; +const IN_503: usize = 0; +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_475], ExecError> { +) -> Result<[G; OUT_503], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(46); let __v_1: G = G::from_u64(163); @@ -42274,21 +44356,21 @@ fn aiur_fn_475( let __v_30: G = G::from_u64(126); let __v_31: G = G::from_u64(143); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_475] = [__v_32]; - if let Some(result) = record.function_queries[475].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_503] = [__v_32]; + if let Some(result) = record.function_queries[503].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_476: usize = 0; -const IN_476: usize = 0; -const OUT_476: usize = 1; -fn aiur_fn_476( - inp: [G; IN_476], +const INPUT_SIZE_504: usize = 0; +const IN_504: usize = 0; +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_476], ExecError> { +) -> Result<[G; OUT_504], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(158); @@ -42323,21 +44405,21 @@ fn aiur_fn_476( let __v_30: G = G::from_u64(131); let __v_31: G = G::from_u64(129); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_476] = [__v_32]; - if let Some(result) = record.function_queries[476].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_504] = [__v_32]; + if let Some(result) = record.function_queries[504].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_477: usize = 0; -const IN_477: usize = 0; -const OUT_477: usize = 1; -fn aiur_fn_477( - inp: [G; IN_477], +const INPUT_SIZE_505: usize = 0; +const IN_505: usize = 0; +const OUT_505: usize = 1; +fn aiur_fn_505( + inp: [G; IN_505], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_477], ExecError> { +) -> Result<[G; OUT_505], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(4); let __v_1: G = G::from_u64(113); @@ -42372,21 +44454,21 @@ fn aiur_fn_477( let __v_30: G = G::from_u64(87); let __v_31: G = G::from_u64(149); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_477] = [__v_32]; - if let Some(result) = record.function_queries[477].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_505] = [__v_32]; + if let Some(result) = record.function_queries[505].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_478: usize = 0; -const IN_478: usize = 0; -const OUT_478: usize = 1; -fn aiur_fn_478( - inp: [G; IN_478], +const INPUT_SIZE_506: usize = 0; +const IN_506: usize = 0; +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_478], ExecError> { +) -> Result<[G; OUT_506], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(4); let __v_1: G = G::from_u64(42); @@ -42421,21 +44503,21 @@ fn aiur_fn_478( let __v_30: G = G::from_u64(142); let __v_31: G = G::from_u64(179); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_478] = [__v_32]; - if let Some(result) = record.function_queries[478].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_506] = [__v_32]; + if let Some(result) = record.function_queries[506].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_479: usize = 0; -const IN_479: usize = 0; -const OUT_479: usize = 1; -fn aiur_fn_479( - inp: [G; IN_479], +const INPUT_SIZE_507: usize = 0; +const IN_507: usize = 0; +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_479], ExecError> { +) -> Result<[G; OUT_507], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(125); let __v_1: G = G::from_u64(175); @@ -42470,21 +44552,21 @@ fn aiur_fn_479( let __v_30: G = G::from_u64(175); let __v_31: G = G::from_u64(221); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_479] = [__v_32]; - if let Some(result) = record.function_queries[479].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_507] = [__v_32]; + if let Some(result) = record.function_queries[507].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_480: usize = 0; -const IN_480: usize = 0; -const OUT_480: usize = 1; -fn aiur_fn_480( - inp: [G; IN_480], +const INPUT_SIZE_508: usize = 0; +const IN_508: usize = 0; +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_480], ExecError> { +) -> Result<[G; OUT_508], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(248); let __v_1: G = G::from_u64(49); @@ -42519,21 +44601,21 @@ fn aiur_fn_480( let __v_30: G = G::from_u64(58); let __v_31: G = G::from_u64(16); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_480] = [__v_32]; - if let Some(result) = record.function_queries[480].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_508] = [__v_32]; + if let Some(result) = record.function_queries[508].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_481: usize = 0; -const IN_481: usize = 0; -const OUT_481: usize = 1; -fn aiur_fn_481( - inp: [G; IN_481], +const INPUT_SIZE_509: usize = 0; +const IN_509: usize = 0; +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_481], ExecError> { +) -> Result<[G; OUT_509], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(122); let __v_1: G = G::from_u64(236); @@ -42568,21 +44650,21 @@ fn aiur_fn_481( let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(194); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_481] = [__v_32]; - if let Some(result) = record.function_queries[481].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_509] = [__v_32]; + if let Some(result) = record.function_queries[509].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_482: usize = 0; -const IN_482: usize = 0; -const OUT_482: usize = 1; -fn aiur_fn_482( - inp: [G; IN_482], +const INPUT_SIZE_510: usize = 0; +const IN_510: usize = 0; +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_482], ExecError> { +) -> Result<[G; OUT_510], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(230); let __v_1: G = G::from_u64(235); @@ -42617,21 +44699,21 @@ fn aiur_fn_482( let __v_30: G = G::from_u64(160); let __v_31: G = G::from_u64(164); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_482] = [__v_32]; - if let Some(result) = record.function_queries[482].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_510] = [__v_32]; + if let Some(result) = record.function_queries[510].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_483: usize = 0; -const IN_483: usize = 0; -const OUT_483: usize = 1; -fn aiur_fn_483( - inp: [G; IN_483], +const INPUT_SIZE_511: usize = 0; +const IN_511: usize = 0; +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_483], ExecError> { +) -> Result<[G; OUT_511], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(108); let __v_1: G = G::from_u64(155); @@ -42666,21 +44748,21 @@ fn aiur_fn_483( let __v_30: G = G::from_u64(173); let __v_31: G = G::from_u64(206); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_483] = [__v_32]; - if let Some(result) = record.function_queries[483].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_511] = [__v_32]; + if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_484: usize = 0; -const IN_484: usize = 0; -const OUT_484: usize = 1; -fn aiur_fn_484( - inp: [G; IN_484], +const INPUT_SIZE_512: usize = 0; +const IN_512: usize = 0; +const OUT_512: usize = 1; +fn aiur_fn_512( + inp: [G; IN_512], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_484], ExecError> { +) -> Result<[G; OUT_512], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(15); let __v_1: G = G::from_u64(83); @@ -42715,21 +44797,21 @@ fn aiur_fn_484( let __v_30: G = G::from_u64(244); let __v_31: G = G::from_u64(248); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_484] = [__v_32]; - if let Some(result) = record.function_queries[484].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_512] = [__v_32]; + if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_485: usize = 0; -const IN_485: usize = 0; -const OUT_485: usize = 1; -fn aiur_fn_485( - inp: [G; IN_485], +const INPUT_SIZE_513: usize = 0; +const IN_513: usize = 0; +const OUT_513: usize = 1; +fn aiur_fn_513( + inp: [G; IN_513], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_485], ExecError> { +) -> Result<[G; OUT_513], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(14); let __v_1: G = G::from_u64(95); @@ -42764,21 +44846,21 @@ fn aiur_fn_485( let __v_30: G = G::from_u64(63); let __v_31: G = G::from_u64(174); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_485] = [__v_32]; - if let Some(result) = record.function_queries[485].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_513] = [__v_32]; + if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_486: usize = 0; -const IN_486: usize = 0; -const OUT_486: usize = 1; -fn aiur_fn_486( - inp: [G; IN_486], +const INPUT_SIZE_514: usize = 0; +const IN_514: usize = 0; +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_486], ExecError> { +) -> Result<[G; OUT_514], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(206); let __v_1: G = G::from_u64(19); @@ -42813,196 +44895,98 @@ fn aiur_fn_486( let __v_30: G = G::from_u64(16); let __v_31: G = G::from_u64(140); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_486] = [__v_32]; - if let Some(result) = record.function_queries[486].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_514] = [__v_32]; + if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_487: usize = 0; -const IN_487: usize = 0; -const OUT_487: usize = 1; -fn aiur_fn_487( - inp: [G; IN_487], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_487], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(9); - let __v_1: G = G::from_u64(188); - let __v_2: G = G::from_u64(37); - let __v_3: G = G::from_u64(49); - let __v_4: G = G::from_u64(71); - let __v_5: G = G::from_u64(195); - let __v_6: G = G::from_u64(108); - let __v_7: G = G::from_u64(226); - let __v_8: G = G::from_u64(44); - let __v_9: G = G::from_u64(142); - let __v_10: G = G::from_u64(12); - let __v_11: G = G::from_u64(205); - let __v_12: G = G::from_u64(67); - let __v_13: G = G::from_u64(199); - let __v_14: G = G::from_u64(155); - let __v_15: G = G::from_u64(44); - let __v_16: G = G::from_u64(218); - let __v_17: G = G::from_u64(226); - let __v_18: G = G::from_u64(32); - let __v_19: G = G::from_u64(110); - let __v_20: G = G::from_u64(13); - let __v_21: G = G::from_u64(221); - let __v_22: G = G::from_u64(22); - let __v_23: G = G::from_u64(143); - let __v_24: G = G::from_u64(202); - let __v_25: G = G::from_u64(54); - let __v_26: G = G::from_u64(9); - let __v_27: G = G::from_u64(178); - let __v_28: G = G::from_u64(165); - let __v_29: G = G::from_u64(132); - let __v_30: G = G::from_u64(211); - let __v_31: G = G::from_u64(220); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_487] = [__v_32]; - if let Some(result) = record.function_queries[487].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_488: usize = 0; -const IN_488: usize = 0; -const OUT_488: usize = 1; -fn aiur_fn_488( - inp: [G; IN_488], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, - unconstrained: bool, -) -> Result<[G; OUT_488], ExecError> { - stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { - let __v_0: G = G::from_u64(38); - let __v_1: G = G::from_u64(124); - let __v_2: G = G::from_u64(10); - let __v_3: G = G::from_u64(156); - let __v_4: G = G::from_u64(146); - let __v_5: G = G::from_u64(231); - let __v_6: G = G::from_u64(86); - let __v_7: G = G::from_u64(56); - let __v_8: G = G::from_u64(252); - let __v_9: G = G::from_u64(115); - let __v_10: G = G::from_u64(237); - let __v_11: G = G::from_u64(82); - let __v_12: G = G::from_u64(169); - let __v_13: G = G::from_u64(249); - let __v_14: G = G::from_u64(200); - let __v_15: G = G::from_u64(22); - let __v_16: G = G::from_u64(71); - let __v_17: G = G::from_u64(238); - let __v_18: G = G::from_u64(236); - let __v_19: G = G::from_u64(238); - let __v_20: G = G::from_u64(255); - let __v_21: G = G::from_u64(33); - let __v_22: G = G::from_u64(68); - let __v_23: G = G::from_u64(193); - let __v_24: G = G::from_u64(249); - let __v_25: G = G::from_u64(126); - let __v_26: G = G::from_u64(101); - let __v_27: G = G::from_u64(226); - let __v_28: G = G::from_u64(175); - let __v_29: G = G::from_u64(241); - let __v_30: G = G::from_u64(73); - let __v_31: G = G::from_u64(241); - let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_488] = [__v_32]; - if let Some(result) = record.function_queries[488].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; - return Ok(__ret); - }) -} - -const INPUT_SIZE_489: usize = 1; -const IN_489: usize = 1; -const OUT_489: usize = 1; -fn aiur_fn_489( - inp: [G; IN_489], +const INPUT_SIZE_515: usize = 1; +const IN_515: usize = 1; +const OUT_515: usize = 1; +fn aiur_fn_515( + inp: [G; IN_515], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_489], ExecError> { +) -> Result<[G; OUT_515], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_489] = [__v_3]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_3]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_489] = [__v_5]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_5]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_489] = [__v_7]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_7]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_489] = [__v_9]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_9]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_489] = [__v_11]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_11]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { let __v_13: G = G::from_u64(1); - let __ret: [G; OUT_489] = [__v_13]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_13]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_489] = [__v_13]; - if let Some(result) = record.function_queries[489].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_515] = [__v_13]; + if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43019,56 +45003,56 @@ fn aiur_fn_489( }) } -const INPUT_SIZE_490: usize = 1; -const IN_490: usize = 1; -const OUT_490: usize = 1; -fn aiur_fn_490( - inp: [G; IN_490], +const INPUT_SIZE_516: usize = 1; +const IN_516: usize = 1; +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_490], ExecError> { +) -> Result<[G; OUT_516], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_485(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_490] = [__v_3]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_3]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_484(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_490] = [__v_5]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_5]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_486(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __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_490] = [__v_7]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_7]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_490] = [__v_7]; - if let Some(result) = record.function_queries[490].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_516] = [__v_7]; + if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43079,15 +45063,15 @@ fn aiur_fn_490( }) } -const INPUT_SIZE_491: usize = 1; -const IN_491: usize = 1; -const OUT_491: usize = 3; -fn aiur_fn_491( - inp: [G; IN_491], +const INPUT_SIZE_517: usize = 1; +const IN_517: usize = 1; +const OUT_517: usize = 3; +fn aiur_fn_517( + inp: [G; IN_517], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_491], ExecError> { +) -> Result<[G; OUT_517], 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 }; @@ -43104,11 +45088,11 @@ fn aiur_fn_491( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; @@ -43120,8 +45104,8 @@ fn aiur_fn_491( let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 10] = [__v_16, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_491] = [__v_14, __v_15, __v_18]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_14, __v_15, __v_18]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43135,8 +45119,8 @@ fn aiur_fn_491( match __v_15.as_canonical_u64() { 0u64 => { let __v_18: G = G::from_u64(1); - let __ret: [G; OUT_491] = [__v_18, __v_12, __v_16]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_18, __v_12, __v_16]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43145,8 +45129,8 @@ fn aiur_fn_491( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_491] = [__v_18, __v_19, __v_22]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_18, __v_19, __v_22]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43157,8 +45141,8 @@ fn aiur_fn_491( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_491] = [__v_18, __v_19, __v_22]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_18, __v_19, __v_22]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43171,8 +45155,8 @@ fn aiur_fn_491( 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_491] = [__v_9, __v_10, __v_13]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_9, __v_10, __v_13]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43183,34 +45167,34 @@ fn aiur_fn_491( 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_491] = [__v_5, __v_6, __v_9]; - if let Some(result) = record.function_queries[491].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_517] = [__v_5, __v_6, __v_9]; + if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_492: usize = 2; -const IN_492: usize = 2; -const OUT_492: usize = 1; -fn aiur_fn_492( - inp: [G; IN_492], +const INPUT_SIZE_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_492], ExecError> { +) -> Result<[G; OUT_518], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_487(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_146(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, _ => { - let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_147(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; break '__mc_0 [__v_2]; }, @@ -43230,27 +45214,27 @@ fn aiur_fn_492( let __v_13: G = G::from_u64(3); let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_13, __v_8, __v_12, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_492] = [__v_15]; - if let Some(result) = record.function_queries[492].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_518] = [__v_15]; + if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_493: usize = 4; -const IN_493: usize = 4; -const OUT_493: usize = 2; -fn aiur_fn_493( - inp: [G; IN_493], +const INPUT_SIZE_519: usize = 4; +const IN_519: usize = 4; +const OUT_519: usize = 2; +fn aiur_fn_519( + inp: [G; IN_519], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_493], ExecError> { +) -> Result<[G; OUT_519], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -43261,24 +45245,24 @@ fn aiur_fn_493( 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_493] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -43289,26 +45273,26 @@ fn aiur_fn_493( 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_493] = [__v_17, __v_21]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_17, __v_21]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_493] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_494(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_493] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[493].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_519] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43317,15 +45301,15 @@ fn aiur_fn_493( }) } -const INPUT_SIZE_494: usize = 6; -const IN_494: usize = 6; -const OUT_494: usize = 2; -fn aiur_fn_494( - inp: [G; IN_494], +const INPUT_SIZE_520: usize = 6; +const IN_520: usize = 6; +const OUT_520: usize = 2; +fn aiur_fn_520( + inp: [G; IN_520], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_494], ExecError> { +) -> Result<[G; OUT_520], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43333,25 +45317,25 @@ fn aiur_fn_494( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_491(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_492(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_492(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(2); let __v_17: G = G::from_u64(0); @@ -43363,13 +45347,13 @@ fn aiur_fn_494( let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_25: G = G::from_u64(2); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_24, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __ret: [G; OUT_494] = [__v_27, __v_28]; - if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_520] = [__v_27, __v_28]; + if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43378,8 +45362,8 @@ fn aiur_fn_494( 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_494] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_520] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43390,29 +45374,29 @@ fn aiur_fn_494( 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_494] = [__v_11, __v_15]; - if let Some(result) = record.function_queries[494].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_520] = [__v_11, __v_15]; + if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_495: usize = 4; -const IN_495: usize = 4; -const OUT_495: usize = 2; -fn aiur_fn_495( - inp: [G; IN_495], +const INPUT_SIZE_521: usize = 4; +const IN_521: usize = 4; +const OUT_521: usize = 2; +fn aiur_fn_521( + inp: [G; IN_521], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_495], ExecError> { +) -> Result<[G; OUT_521], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(2); let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -43423,50 +45407,50 @@ fn aiur_fn_495( 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_495] = [__v_7, __v_11]; - if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_7, __v_11]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_490(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_493(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_495] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_474(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_475(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_496(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_522(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_495] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_497(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_523(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_495] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[495].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_521] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43477,28 +45461,28 @@ fn aiur_fn_495( }) } -const INPUT_SIZE_496: usize = 3; -const IN_496: usize = 3; -const OUT_496: usize = 2; -fn aiur_fn_496( - inp: [G; IN_496], +const INPUT_SIZE_522: usize = 3; +const IN_522: usize = 3; +const OUT_522: usize = 2; +fn aiur_fn_522( + inp: [G; IN_522], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_496], ExecError> { +) -> Result<[G; OUT_522], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; match __v_8.as_canonical_u64() { @@ -43508,17 +45492,17 @@ fn aiur_fn_496( 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_496] = [__v_10, __v_14]; - if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_522] = [__v_10, __v_14]; + if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_112(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_232(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_245(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(2); - let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_473(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_0, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -43529,13 +45513,13 @@ fn aiur_fn_496( let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 4] = [__v_19, __v_18, __v_6, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = G::from_u64(2); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_496] = [__v_24, __v_25]; - if let Some(result) = record.function_queries[496].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_522] = [__v_24, __v_25]; + if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43545,15 +45529,15 @@ fn aiur_fn_496( }) } -const INPUT_SIZE_497: usize = 6; -const IN_497: usize = 6; -const OUT_497: usize = 2; -fn aiur_fn_497( - inp: [G; IN_497], +const INPUT_SIZE_523: usize = 6; +const IN_523: usize = 6; +const OUT_523: usize = 2; +fn aiur_fn_523( + inp: [G; IN_523], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_497], ExecError> { +) -> Result<[G; OUT_523], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43562,16 +45546,16 @@ fn aiur_fn_497( let __v_4: G = inp[4]; let __v_5: G = inp[5]; let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_7, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_9, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; match __v_12.as_canonical_u64() { @@ -43581,12 +45565,12 @@ fn aiur_fn_497( 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_497] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_523] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_230(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_243(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; match __v_14.as_canonical_u64() { @@ -43596,8 +45580,8 @@ fn aiur_fn_497( 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_497] = [__v_16, __v_20]; - if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_523] = [__v_16, __v_20]; + if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -43608,18 +45592,18 @@ fn aiur_fn_497( break '__mc_0 [__v_16]; }, _ => { - let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_316(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_338(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, } }; let __v_16: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_498(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_497] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[497].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_523] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43634,15 +45618,15 @@ fn aiur_fn_497( }) } -const INPUT_SIZE_498: usize = 9; -const IN_498: usize = 9; -const OUT_498: usize = 2; -fn aiur_fn_498( - inp: [G; IN_498], +const INPUT_SIZE_524: usize = 9; +const IN_524: usize = 9; +const OUT_524: usize = 2; +fn aiur_fn_524( + inp: [G; IN_524], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_498], ExecError> { +) -> Result<[G; OUT_524], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43663,8 +45647,8 @@ fn aiur_fn_498( 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_498] = [__v_12, __v_16]; - if let Some(result) = record.function_queries[498].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_12, __v_16]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -43680,12 +45664,12 @@ fn aiur_fn_498( let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_17, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(2); - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_22, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_27: G = G::from_u64(2); - let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_482(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); @@ -43694,12 +45678,12 @@ fn aiur_fn_498( let __v_33: G = { let __values: [G; 4] = [__v_27, __v_28, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_160(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_172(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, _ => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_161(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_173(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; break '__mc_0 [__v_34]; }, @@ -43722,12 +45706,12 @@ fn aiur_fn_498( 1u64 => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_478(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_479(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -43736,12 +45720,12 @@ fn aiur_fn_498( _ => { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_480(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, _ => { - let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_481(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; break '__mc_1 [__v_47]; }, @@ -43765,31 +45749,31 @@ fn aiur_fn_498( let __v_60: G = G::from_u64(3); let __v_61: G = G::from_u64(0); let __v_62: G = { let __values: [G; 4] = [__v_60, __v_59, __v_46, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_501(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; - let __ret: [G; OUT_498] = [__v_63, __v_64]; - if let Some(result) = record.function_queries[498].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_524] = [__v_63, __v_64]; + if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_499: usize = 3; -const IN_499: usize = 3; -const OUT_499: usize = 2; -fn aiur_fn_499( - inp: [G; IN_499], +const INPUT_SIZE_525: usize = 3; +const IN_525: usize = 3; +const OUT_525: usize = 2; +fn aiur_fn_525( + inp: [G; IN_525], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_499], ExecError> { +) -> Result<[G; OUT_525], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(2); let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -43800,16 +45784,16 @@ fn aiur_fn_499( 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_499] = [__v_6, __v_10]; - if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_6, __v_10]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -43829,7 +45813,7 @@ fn aiur_fn_499( 7u64 => { match __v_15.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; match __v_18.as_canonical_u64() { 0u64 => { @@ -43838,16 +45822,16 @@ fn aiur_fn_499( 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_499] = [__v_19, __v_23]; - if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_19, __v_23]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_499] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43858,8 +45842,8 @@ fn aiur_fn_499( 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_499] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43870,8 +45854,8 @@ fn aiur_fn_499( 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_499] = [__v_18, __v_22]; - if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_18, __v_22]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43882,8 +45866,8 @@ fn aiur_fn_499( 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_499] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43894,8 +45878,8 @@ fn aiur_fn_499( 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_499] = [__v_14, __v_18]; - if let Some(result) = record.function_queries[499].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_525] = [__v_14, __v_18]; + if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -43904,15 +45888,15 @@ fn aiur_fn_499( }) } -const INPUT_SIZE_500: usize = 4; -const IN_500: usize = 4; -const OUT_500: usize = 2; -fn aiur_fn_500( - inp: [G; IN_500], +const INPUT_SIZE_526: usize = 4; +const IN_526: usize = 4; +const OUT_526: usize = 2; +fn aiur_fn_526( + inp: [G; IN_526], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_500], ExecError> { +) -> Result<[G; OUT_526], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -43930,12 +45914,12 @@ fn aiur_fn_500( let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_14: G = { let __values: [G; 3] = [__v_10, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = G::from_u64(2); - let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_483(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_19: G = G::from_u64(2); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_206(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_218(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); @@ -43959,18 +45943,18 @@ fn aiur_fn_500( let __v_40: G = G::from_u64(0); let __v_41: G = { let __values: [G; 4] = [__v_36, __v_1, __v_39, __v_40]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = G::from_u64(2); - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_44, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_45, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(1); let __v_51: G = { let __a_val = __v_49.as_canonical_u64(); let __b_val = __v_50.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -43981,16 +45965,16 @@ fn aiur_fn_500( 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_500] = [__v_52, __v_56]; - if let Some(result) = record.function_queries[500].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_526] = [__v_52, __v_56]; + if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_48, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(2); - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(1); let __v_57: G = G::from_u64(1); @@ -44004,28 +45988,28 @@ fn aiur_fn_500( let __v_65: G = G::from_u64(0); let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_35, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_67: G = G::from_u64(2); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_66, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __ret: [G; OUT_500] = [__v_69, __v_70]; - if let Some(result) = record.function_queries[500].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_526] = [__v_69, __v_70]; + if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_501: usize = 6; -const IN_501: usize = 6; -const OUT_501: usize = 2; -fn aiur_fn_501( - inp: [G; IN_501], +const INPUT_SIZE_527: usize = 6; +const IN_527: usize = 6; +const OUT_527: usize = 2; +fn aiur_fn_527( + inp: [G; IN_527], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_501], ExecError> { +) -> Result<[G; OUT_527], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44035,12 +46019,12 @@ fn aiur_fn_501( let __v_5: G = inp[5]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_476(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, _ => { - let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_477(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; break '__mc_0 [__v_6]; }, @@ -44051,18 +46035,18 @@ fn aiur_fn_501( let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_2, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(2); - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_460(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_488(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(1); let __v_19: G = { let __a_val = __v_17.as_canonical_u64(); let __b_val = __v_18.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; @@ -44073,13 +46057,13 @@ fn aiur_fn_501( 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_501] = [__v_20, __v_24]; - if let Some(result) = record.function_queries[501].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_527] = [__v_20, __v_24]; + if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_16, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(2); let __v_23: G = G::from_u64(1); @@ -44094,28 +46078,28 @@ fn aiur_fn_501( let __v_32: G = G::from_u64(0); let __v_33: G = { let __values: [G; 4] = [__v_31, __v_30, __v_1, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = G::from_u64(2); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(1); - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_501] = [__v_36, __v_37]; - if let Some(result) = record.function_queries[501].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_527] = [__v_36, __v_37]; + if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_502: usize = 2; -const IN_502: usize = 2; -const OUT_502: usize = 1; -fn aiur_fn_502( - inp: [G; IN_502], +const INPUT_SIZE_528: usize = 2; +const IN_528: usize = 2; +const OUT_528: usize = 1; +fn aiur_fn_528( + inp: [G; IN_528], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_502], ExecError> { +) -> Result<[G; OUT_528], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44123,8 +46107,8 @@ fn aiur_fn_502( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_502] = [__v_3]; - if let Some(result) = record.function_queries[502].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_528] = [__v_3]; + if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44132,14 +46116,14 @@ fn aiur_fn_502( match __v_3.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_502] = [__v_4]; - if let Some(result) = record.function_queries[502].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_528] = [__v_4]; + if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_502] = [__v_4]; - if let Some(result) = record.function_queries[502].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_528] = [__v_4]; + if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44151,96 +46135,96 @@ fn aiur_fn_502( }) } -const INPUT_SIZE_503: usize = 2; -const IN_503: usize = 2; -const OUT_503: usize = 1; -fn aiur_fn_503( - inp: [G; IN_503], +const INPUT_SIZE_529: usize = 2; +const IN_529: usize = 2; +const OUT_529: usize = 1; +fn aiur_fn_529( + inp: [G; IN_529], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_503], ExecError> { +) -> Result<[G; OUT_529], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_503] = [__v_1]; - if let Some(result) = record.function_queries[503].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_529] = [__v_1]; + if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_503] = [__v_0]; - if let Some(result) = record.function_queries[503].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_529] = [__v_0]; + if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_504: usize = 0; -const IN_504: usize = 0; -const OUT_504: usize = 2; -fn aiur_fn_504( - inp: [G; IN_504], +const INPUT_SIZE_530: usize = 0; +const IN_530: usize = 0; +const OUT_530: usize = 2; +fn aiur_fn_530( + inp: [G; IN_530], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_504], ExecError> { +) -> Result<[G; OUT_530], 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_504] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[504].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_530] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[530].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_505: usize = 0; -const IN_505: usize = 0; -const OUT_505: usize = 2; -fn aiur_fn_505( - inp: [G; IN_505], +const INPUT_SIZE_531: usize = 0; +const IN_531: usize = 0; +const OUT_531: usize = 2; +fn aiur_fn_531( + inp: [G; IN_531], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_505], ExecError> { +) -> Result<[G; OUT_531], 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_505] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[505].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_531] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[531].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_506: usize = 0; -const IN_506: usize = 0; -const OUT_506: usize = 2; -fn aiur_fn_506( - inp: [G; IN_506], +const INPUT_SIZE_532: usize = 0; +const IN_532: usize = 0; +const OUT_532: usize = 2; +fn aiur_fn_532( + inp: [G; IN_532], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_506], ExecError> { +) -> Result<[G; OUT_532], 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_506] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[506].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_532] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_507: usize = 4; -const IN_507: usize = 4; -const OUT_507: usize = 2; -fn aiur_fn_507( - inp: [G; IN_507], +const INPUT_SIZE_533: usize = 4; +const IN_533: usize = 4; +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_507], ExecError> { +) -> Result<[G; OUT_533], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44249,46 +46233,46 @@ fn aiur_fn_507( match __v_0.as_canonical_u64() { 1u64 => { let __v_4: G = (__v_1 * __v_3); - let __ret: [G; OUT_507] = [__v_2, __v_4]; - if let Some(result) = record.function_queries[507].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_533] = [__v_2, __v_4]; + if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_507] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[507].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_533] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_508: usize = 1; -const IN_508: usize = 1; -const OUT_508: usize = 2; -fn aiur_fn_508( - inp: [G; IN_508], +const INPUT_SIZE_534: usize = 1; +const IN_534: usize = 1; +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_508], ExecError> { +) -> Result<[G; OUT_534], 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_508] = [__v_0, __v_1]; - if let Some(result) = record.function_queries[508].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_534] = [__v_0, __v_1]; + if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_509: usize = 2; -const IN_509: usize = 2; -const OUT_509: usize = 1; -fn aiur_fn_509( - inp: [G; IN_509], +const INPUT_SIZE_535: usize = 2; +const IN_535: usize = 2; +const OUT_535: usize = 1; +fn aiur_fn_535( + inp: [G; IN_535], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_509], ExecError> { +) -> Result<[G; OUT_535], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44358,51 +46342,51 @@ fn aiur_fn_509( let __v_63: G = __loaded[29]; let __v_64: G = __loaded[30]; let __v_65: G = __loaded[31]; - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_510(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_536(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_70, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_69, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_68, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_67, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_66, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_509] = [__v_80]; - if let Some(result) = record.function_queries[509].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_535] = [__v_80]; + if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_510: usize = 8; -const IN_510: usize = 8; -const OUT_510: usize = 1; -fn aiur_fn_510( - inp: [G; IN_510], +const INPUT_SIZE_536: usize = 8; +const IN_536: usize = 8; +const OUT_536: usize = 1; +fn aiur_fn_536( + inp: [G; IN_536], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_510], ExecError> { +) -> Result<[G; OUT_536], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44430,23 +46414,23 @@ fn aiur_fn_510( let __v_23: G = (__v_22 + __v_7); let __v_24: G = (__v_20 + __v_23); let __v_25: G = (__v_18 + __v_24); - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_16, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_510] = [__v_26]; - if let Some(result) = record.function_queries[510].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_536] = [__v_26]; + if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_511: usize = 2; -const IN_511: usize = 2; -const OUT_511: usize = 1; -fn aiur_fn_511( - inp: [G; IN_511], +const INPUT_SIZE_537: usize = 2; +const IN_537: usize = 2; +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_511], ExecError> { +) -> Result<[G; OUT_537], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44458,8 +46442,8 @@ fn aiur_fn_511( match __v_2.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_511] = [__v_6]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_6]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -44469,15 +46453,15 @@ fn aiur_fn_511( 1u64 => { let __v_7: G = G::from_u64(1); let __v_8: G = (__v_7 + __v_4); - let __ret: [G; OUT_511] = [__v_8]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_8]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_511] = [__v_7]; - if let Some(result) = record.function_queries[511].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_537] = [__v_7]; + if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44489,15 +46473,15 @@ fn aiur_fn_511( }) } -const INPUT_SIZE_512: usize = 3; -const IN_512: usize = 3; -const OUT_512: usize = 2; -fn aiur_fn_512( - inp: [G; IN_512], +const INPUT_SIZE_538: usize = 3; +const IN_538: usize = 3; +const OUT_538: usize = 2; +fn aiur_fn_538( + inp: [G; IN_538], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_512], ExecError> { +) -> Result<[G; OUT_538], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44506,37 +46490,37 @@ fn aiur_fn_512( let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_512] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_511(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_509(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_512] = [__v_7, __v_8]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_7, __v_8]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_512] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44544,19 +46528,19 @@ fn aiur_fn_512( _ => { match __v_5.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __ret: [G; OUT_512] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_512] = [__v_6, __v_7]; - if let Some(result) = record.function_queries[512].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_538] = [__v_6, __v_7]; + if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44567,15 +46551,15 @@ fn aiur_fn_512( }) } -const INPUT_SIZE_513: usize = 2; -const IN_513: usize = 2; -const OUT_513: usize = 1; -fn aiur_fn_513( - inp: [G; IN_513], +const INPUT_SIZE_539: usize = 2; +const IN_539: usize = 2; +const OUT_539: usize = 1; +fn aiur_fn_539( + inp: [G; IN_539], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_513], ExecError> { +) -> Result<[G; OUT_539], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44592,14 +46576,14 @@ fn aiur_fn_513( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44612,21 +46596,21 @@ fn aiur_fn_513( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44639,31 +46623,31 @@ fn aiur_fn_513( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_513] = [__v_10]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_10]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44676,37 +46660,37 @@ fn aiur_fn_513( match __v_5.as_canonical_u64() { 0u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_513] = [__v_10]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_10]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44721,16 +46705,16 @@ fn aiur_fn_513( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_513] = [__v_8]; - if let Some(result) = record.function_queries[513].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_539] = [__v_8]; + if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44742,15 +46726,15 @@ fn aiur_fn_513( }) } -const INPUT_SIZE_514: usize = 2; -const IN_514: usize = 2; -const OUT_514: usize = 1; -fn aiur_fn_514( - inp: [G; IN_514], +const INPUT_SIZE_540: usize = 2; +const IN_540: usize = 2; +const OUT_540: usize = 1; +fn aiur_fn_540( + inp: [G; IN_540], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_514], ExecError> { +) -> Result<[G; OUT_540], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44767,14 +46751,14 @@ fn aiur_fn_514( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_514] = [__v_8]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_540] = [__v_8]; + if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_514] = [__v_8]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_540] = [__v_8]; + if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -44787,19 +46771,19 @@ fn aiur_fn_514( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_514] = [__v_8]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_540] = [__v_8]; + if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_514] = [__v_10]; - if let Some(result) = record.function_queries[514].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_540] = [__v_10]; + if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44814,15 +46798,15 @@ fn aiur_fn_514( }) } -const INPUT_SIZE_515: usize = 4; -const IN_515: usize = 4; -const OUT_515: usize = 1; -fn aiur_fn_515( - inp: [G; IN_515], +const INPUT_SIZE_541: usize = 4; +const IN_541: usize = 4; +const OUT_541: usize = 1; +fn aiur_fn_541( + inp: [G; IN_541], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_515], ExecError> { +) -> Result<[G; OUT_541], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44832,16 +46816,16 @@ fn aiur_fn_515( 0u64 => { match __v_2.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_516(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_515] = [__v_4]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_4]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_515] = [__v_4]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_4]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44853,15 +46837,15 @@ fn aiur_fn_515( match __v_2.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(2); - let __ret: [G; OUT_515] = [__v_4]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_4]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_515] = [__v_4]; - if let Some(result) = record.function_queries[515].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_541] = [__v_4]; + if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44876,15 +46860,15 @@ fn aiur_fn_515( }) } -const INPUT_SIZE_516: usize = 2; -const IN_516: usize = 2; -const OUT_516: usize = 1; -fn aiur_fn_516( - inp: [G; IN_516], +const INPUT_SIZE_542: usize = 2; +const IN_542: usize = 2; +const OUT_542: usize = 1; +fn aiur_fn_542( + inp: [G; IN_542], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_516], ExecError> { +) -> Result<[G; OUT_542], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44892,38 +46876,38 @@ fn aiur_fn_516( let __v_2: G = __r_arr[0]; let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_118(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_516] = [__v_7]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_542] = [__v_7]; + if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_516] = [__v_6]; - if let Some(result) = record.function_queries[516].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_542] = [__v_6]; + if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_517: usize = 2; -const IN_517: usize = 2; -const OUT_517: usize = 1; -fn aiur_fn_517( - inp: [G; IN_517], +const INPUT_SIZE_543: usize = 2; +const IN_543: usize = 2; +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_517], ExecError> { +) -> Result<[G; OUT_543], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -44941,8 +46925,8 @@ fn aiur_fn_517( match __v_2.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_517] = [__v_12]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_12]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -44959,14 +46943,14 @@ fn aiur_fn_517( let __v_21: G = __loaded[9]; match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_517(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__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[518].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_518(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__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[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_517] = [__v_24]; - if let Some(result) = record.function_queries[517].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_543] = [__v_24]; + if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -44981,15 +46965,15 @@ fn aiur_fn_517( }) } -const INPUT_SIZE_518: usize = 16; -const IN_518: usize = 16; -const OUT_518: usize = 1; -fn aiur_fn_518( - inp: [G; IN_518], +const INPUT_SIZE_544: usize = 16; +const IN_544: usize = 16; +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_518], ExecError> { +) -> Result<[G; OUT_544], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45007,51 +46991,51 @@ fn aiur_fn_518( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_518] = [__v_30]; - if let Some(result) = record.function_queries[518].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_544] = [__v_30]; + if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_519: usize = 2; -const IN_519: usize = 2; -const OUT_519: usize = 1; -fn aiur_fn_519( - inp: [G; IN_519], +const INPUT_SIZE_545: usize = 2; +const IN_545: usize = 2; +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_519], ExecError> { +) -> Result<[G; OUT_545], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45068,14 +47052,14 @@ fn aiur_fn_519( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_519] = [__v_8]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_8]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_519] = [__v_8]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_8]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45088,19 +47072,19 @@ fn aiur_fn_519( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(2); - let __ret: [G; OUT_519] = [__v_8]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_8]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_519(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_503(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_519] = [__v_10]; - if let Some(result) = record.function_queries[519].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_545] = [__v_10]; + if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45115,15 +47099,15 @@ fn aiur_fn_519( }) } -const INPUT_SIZE_520: usize = 3; -const IN_520: usize = 3; -const OUT_520: usize = 2; -fn aiur_fn_520( - inp: [G; IN_520], +const INPUT_SIZE_546: usize = 3; +const IN_546: usize = 3; +const OUT_546: usize = 2; +fn aiur_fn_546( + inp: [G; IN_546], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_520], ExecError> { +) -> Result<[G; OUT_546], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45131,11 +47115,11 @@ fn aiur_fn_520( let __v_3: G = (__v_0 - __v_1); match __v_3.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __ret: [G; OUT_520] = [__v_4, __v_5]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_4, __v_5]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45149,26 +47133,26 @@ fn aiur_fn_520( let __v_9: G = __loaded[1]; let __v_10: G = __loaded[2]; let __v_11: G = __loaded[3]; - let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__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[521].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_521(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__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[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_520] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[520].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_546] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_521: usize = 9; -const IN_521: usize = 9; -const OUT_521: usize = 2; -fn aiur_fn_521( - inp: [G; IN_521], +const INPUT_SIZE_547: usize = 9; +const IN_547: usize = 9; +const OUT_547: usize = 2; +fn aiur_fn_547( + inp: [G; IN_547], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_521], ExecError> { +) -> Result<[G; OUT_547], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45183,21 +47167,21 @@ fn aiur_fn_521( 0u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45205,29 +47189,29 @@ fn aiur_fn_521( 1u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_513(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45235,43 +47219,43 @@ fn aiur_fn_521( 2u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_514(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_14, __v_15]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_14, __v_15]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45279,49 +47263,49 @@ fn aiur_fn_521( 3u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45329,57 +47313,57 @@ fn aiur_fn_521( 4u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45387,65 +47371,65 @@ fn aiur_fn_521( 5u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45453,79 +47437,79 @@ fn aiur_fn_521( 6u64 => { match __v_4.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45533,29 +47517,29 @@ fn aiur_fn_521( 7u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_515(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45563,33 +47547,33 @@ fn aiur_fn_521( 8u64 => { match __v_4.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_512(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; - let __ret: [G; OUT_521] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[521].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_547] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45601,15 +47585,15 @@ fn aiur_fn_521( }) } -const INPUT_SIZE_522: usize = 7; -const IN_522: usize = 7; -const OUT_522: usize = 2; -fn aiur_fn_522( - inp: [G; IN_522], +const INPUT_SIZE_548: usize = 7; +const IN_548: usize = 7; +const OUT_548: usize = 2; +fn aiur_fn_548( + inp: [G; IN_548], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_522], ExecError> { +) -> Result<[G; OUT_548], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45622,19 +47606,19 @@ fn aiur_fn_522( _ => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_522] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[522].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_548] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45643,15 +47627,15 @@ fn aiur_fn_522( }) } -const INPUT_SIZE_523: usize = 3; -const IN_523: usize = 3; -const OUT_523: usize = 2; -fn aiur_fn_523( - inp: [G; IN_523], +const INPUT_SIZE_549: usize = 3; +const IN_549: usize = 3; +const OUT_549: usize = 2; +fn aiur_fn_549( + inp: [G; IN_549], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_523], ExecError> { +) -> Result<[G; OUT_549], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45672,19 +47656,19 @@ fn aiur_fn_523( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_523] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_504(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_523] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45698,25 +47682,25 @@ fn aiur_fn_523( let __v_12: G = __loaded[4]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_506(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[532].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_532(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_532] = unsafe { *(result.output.as_ptr() as *const [G; OUT_532]) }; __ret } } else { aiur_fn_532(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __ret: [G; OUT_523] = [__v_13, __v_14]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_13, __v_14]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_522(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_523(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __ret: [G; OUT_523] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[523].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_549] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45731,15 +47715,15 @@ fn aiur_fn_523( }) } -const INPUT_SIZE_524: usize = 12; -const IN_524: usize = 12; -const OUT_524: usize = 1; -fn aiur_fn_524( - inp: [G; IN_524], +const INPUT_SIZE_550: usize = 12; +const IN_550: usize = 12; +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_524], ExecError> { +) -> Result<[G; OUT_550], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45756,50 +47740,50 @@ fn aiur_fn_524( match __v_0.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_524] = [__v_12]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_12]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_524] = [__v_12]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_12]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_524] = [__v_12]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_12]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_524] = [__v_12]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_12]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_12: G = G::from_u64(2); - let __ret: [G; OUT_524] = [__v_12]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_12]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_12: G = G::from_u64(3); - let __ret: [G; OUT_524] = [__v_12]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_12]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(4); - let __ret: [G; OUT_524] = [__v_12]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_12]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(5); - let __ret: [G; OUT_524] = [__v_12]; - if let Some(result) = record.function_queries[524].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_550] = [__v_12]; + if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -45809,15 +47793,15 @@ fn aiur_fn_524( }) } -const INPUT_SIZE_525: usize = 25; -const IN_525: usize = 25; -const OUT_525: usize = 2; -fn aiur_fn_525( - inp: [G; IN_525], +const INPUT_SIZE_551: usize = 25; +const IN_551: usize = 25; +const OUT_551: usize = 2; +fn aiur_fn_551( + inp: [G; IN_551], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_525], ExecError> { +) -> Result<[G; OUT_551], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45844,42 +47828,42 @@ fn aiur_fn_525( let __v_22: G = inp[22]; let __v_23: G = inp[23]; let __v_24: G = inp[24]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__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[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__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[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; match __v_27.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_526(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_525] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_525] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[525].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_551] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_526: usize = 25; -const IN_526: usize = 25; -const OUT_526: usize = 2; -fn aiur_fn_526( - inp: [G; IN_526], +const INPUT_SIZE_552: usize = 25; +const IN_552: usize = 25; +const OUT_552: usize = 2; +fn aiur_fn_552( + inp: [G; IN_552], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_526], ExecError> { +) -> Result<[G; OUT_552], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -45910,33 +47894,33 @@ fn aiur_fn_526( 1u64 => { match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; - let __ret: [G; OUT_526] = [__v_34, __v_35]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_34, __v_35]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_526] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -45944,75 +47928,75 @@ fn aiur_fn_526( 5u64 => { match __v_12.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; match __v_43.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __ret: [G; OUT_526] = [__v_51, __v_52]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_51, __v_52]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_46: G = __r_arr[0]; let __v_47: G = __r_arr[1]; - let __ret: [G; OUT_526] = [__v_46, __v_47]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_46, __v_47]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_526] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46020,98 +48004,98 @@ fn aiur_fn_526( 7u64 => { match __v_12.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_8, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_523(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = __r_arr[1]; - let __ret: [G; OUT_526] = [__v_59, __v_60]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_59, __v_60]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_526] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = __r_arr[1]; - let __ret: [G; OUT_526] = [__v_25, __v_26]; - if let Some(result) = record.function_queries[526].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_552] = [__v_25, __v_26]; + if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_527: usize = 7; -const IN_527: usize = 7; -const OUT_527: usize = 2; -fn aiur_fn_527( - inp: [G; IN_527], +const INPUT_SIZE_553: usize = 7; +const IN_553: usize = 7; +const OUT_553: usize = 2; +fn aiur_fn_553( + inp: [G; IN_553], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_527], ExecError> { +) -> Result<[G; OUT_553], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46123,15 +48107,15 @@ fn aiur_fn_527( let __v_7: G = (__v_4 - __v_6); match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_505(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_527] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_553] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -46146,7 +48130,7 @@ fn aiur_fn_527( let __v_18: G = __loaded[9]; let __v_19: G = __loaded[10]; let __v_20: G = __loaded[11]; - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_22: G = __loaded[0]; @@ -46161,34 +48145,34 @@ fn aiur_fn_527( let __v_31: G = __loaded[9]; let __v_32: G = __loaded[10]; let __v_33: G = __loaded[11]; - let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_554(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = G::from_u64(1); let __v_37: G = (__v_6 + __v_36); - let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_527(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = __r_arr[1]; - let __ret: [G; OUT_527] = [__v_40, __v_41]; - if let Some(result) = record.function_queries[527].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_553] = [__v_40, __v_41]; + if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_528: usize = 25; -const IN_528: usize = 25; -const OUT_528: usize = 2; -fn aiur_fn_528( - inp: [G; IN_528], +const INPUT_SIZE_554: usize = 25; +const IN_554: usize = 25; +const OUT_554: usize = 2; +fn aiur_fn_554( + inp: [G; IN_554], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_528], ExecError> { +) -> Result<[G; OUT_554], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46219,94 +48203,94 @@ fn aiur_fn_528( 6u64 => { match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_7, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; - let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_520(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_507(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __ret: [G; OUT_528] = [__v_45, __v_46]; - if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_554] = [__v_45, __v_46]; + if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__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[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__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[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_528] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_554] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__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[524].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_524(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__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[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_502(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_528(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_508(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; - let __ret: [G; OUT_528] = [__v_28, __v_29]; - if let Some(result) = record.function_queries[528].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_554] = [__v_28, __v_29]; + if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_529: usize = 3; -const IN_529: usize = 3; -const OUT_529: usize = 1; -fn aiur_fn_529( - inp: [G; IN_529], +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_529], ExecError> { +) -> Result<[G; OUT_555], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(4); - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -46315,7 +48299,7 @@ fn aiur_fn_529( 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_271] = { let __args: [G; IN_271] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -46341,27 +48325,27 @@ fn aiur_fn_529( let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_529] = [__v_34]; - if let Some(result) = record.function_queries[529].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_555] = [__v_34]; + if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_530: usize = 2; -const IN_530: usize = 2; -const OUT_530: usize = 12; -fn aiur_fn_530( - inp: [G; IN_530], +const INPUT_SIZE_556: usize = 2; +const IN_556: usize = 2; +const OUT_556: usize = 12; +fn aiur_fn_556( + inp: [G; IN_556], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_530], ExecError> { +) -> Result<[G; OUT_556], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -46376,25 +48360,25 @@ fn aiur_fn_530( let __v_13: G = __loaded[9]; let __v_14: G = __loaded[10]; let __v_15: G = __loaded[11]; - let __ret: [G; OUT_530] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; - if let Some(result) = record.function_queries[530].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_556] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_531: usize = 2; -const IN_531: usize = 2; -const OUT_531: usize = 1; -fn aiur_fn_531( - inp: [G; IN_531], +const INPUT_SIZE_557: usize = 2; +const IN_557: usize = 2; +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_531], ExecError> { +) -> Result<[G; OUT_557], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -46409,53 +48393,53 @@ fn aiur_fn_531( let __v_13: G = __r_arr[11]; match __v_2.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_531] = [__v_7]; - if let Some(result) = record.function_queries[531].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_557] = [__v_7]; + if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_531] = [__v_14]; - if let Some(result) = record.function_queries[531].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_557] = [__v_14]; + if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_532: usize = 3; -const IN_532: usize = 3; -const OUT_532: usize = 1; -fn aiur_fn_532( - inp: [G; IN_532], +const INPUT_SIZE_558: usize = 3; +const IN_558: usize = 3; +const OUT_558: usize = 1; +fn aiur_fn_558( + inp: [G; IN_558], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_532], ExecError> { +) -> Result<[G; OUT_558], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_532] = [__v_5]; - if let Some(result) = record.function_queries[532].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_558] = [__v_5]; + if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_533: usize = 5; -const IN_533: usize = 5; -const OUT_533: usize = 1; -fn aiur_fn_533( - inp: [G; IN_533], +const INPUT_SIZE_559: usize = 5; +const IN_559: usize = 5; +const OUT_559: usize = 1; +fn aiur_fn_559( + inp: [G; IN_559], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_533], ExecError> { +) -> Result<[G; OUT_559], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46471,23 +48455,23 @@ fn aiur_fn_533( let __v_8: G = G::from_u64(1); let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_533] = [__v_10]; - if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_559] = [__v_10]; + if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_3 + __v_10); let __v_12: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_533] = [__v_14]; - if let Some(result) = record.function_queries[533].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_559] = [__v_14]; + if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46497,15 +48481,15 @@ fn aiur_fn_533( }) } -const INPUT_SIZE_534: usize = 5; -const IN_534: usize = 5; -const OUT_534: usize = 2; -fn aiur_fn_534( - inp: [G; IN_534], +const INPUT_SIZE_560: usize = 5; +const IN_560: usize = 5; +const OUT_560: usize = 2; +fn aiur_fn_560( + inp: [G; IN_560], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_534], ExecError> { +) -> Result<[G; OUT_560], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46522,35 +48506,35 @@ fn aiur_fn_534( let __v_9: G = G::from_u64(1); let __v_10: G = { let __values: [G; 4] = [__v_8, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_534] = [__v_10, __v_11]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_560] = [__v_10, __v_11]; + if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_534(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_531(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_12, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_3, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_17.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_534] = [__v_16, __v_10]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_560] = [__v_16, __v_10]; + if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_534] = [__v_16, __v_9]; - if let Some(result) = record.function_queries[534].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_560] = [__v_16, __v_9]; + if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46562,15 +48546,15 @@ fn aiur_fn_534( }) } -const INPUT_SIZE_535: usize = 5; -const IN_535: usize = 5; -const OUT_535: usize = 1; -fn aiur_fn_535( - inp: [G; IN_535], +const INPUT_SIZE_561: usize = 5; +const IN_561: usize = 5; +const OUT_561: usize = 1; +fn aiur_fn_561( + inp: [G; IN_561], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_535], ExecError> { +) -> Result<[G; OUT_561], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46583,37 +48567,37 @@ fn aiur_fn_535( 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_535] = [__v_8]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_561] = [__v_8]; + if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_529(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_3 + __v_4); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_4 + __v_9); - let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_535(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_535] = [__v_12]; - if let Some(result) = record.function_queries[535].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[535].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_561] = [__v_12]; + if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_536: usize = 3; -const IN_536: usize = 3; -const OUT_536: usize = 1; -fn aiur_fn_536( - inp: [G; IN_536], +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_536], ExecError> { +) -> Result<[G; OUT_562], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46624,26 +48608,26 @@ fn aiur_fn_536( let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_7: G = { let __values: [G; 3] = [__v_3, __v_0, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = G::from_u64(1); - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = (__v_8 + __v_9); - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_536] = [__v_11]; - if let Some(result) = record.function_queries[536].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_562] = [__v_11]; + if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_537: usize = 4; -const IN_537: usize = 4; -const OUT_537: usize = 1; -fn aiur_fn_537( - inp: [G; IN_537], +const INPUT_SIZE_563: usize = 4; +const IN_563: usize = 4; +const OUT_563: usize = 1; +fn aiur_fn_563( + inp: [G; IN_563], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_537], ExecError> { +) -> Result<[G; OUT_563], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46651,33 +48635,33 @@ fn aiur_fn_537( let __v_3: G = inp[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_537] = [__v_0]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_563] = [__v_0]; + if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_533(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_537] = [__v_0]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_563] = [__v_0]; + if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 - __v_9); - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_537] = [__v_11]; - if let Some(result) = record.function_queries[537].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_563] = [__v_11]; + if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46686,15 +48670,15 @@ fn aiur_fn_537( }) } -const INPUT_SIZE_538: usize = 3; -const IN_538: usize = 3; -const OUT_538: usize = 1; -fn aiur_fn_538( - inp: [G; IN_538], +const INPUT_SIZE_564: usize = 3; +const IN_564: usize = 3; +const OUT_564: usize = 1; +fn aiur_fn_564( + inp: [G; IN_564], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_538], ExecError> { +) -> Result<[G; OUT_564], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46708,19 +48692,19 @@ fn aiur_fn_538( let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_564] = [__v_8]; + if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_539(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_538(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_538] = [__v_8]; - if let Some(result) = record.function_queries[538].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_564] = [__v_8]; + if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46730,28 +48714,28 @@ fn aiur_fn_538( }) } -const INPUT_SIZE_539: usize = 3; -const IN_539: usize = 3; -const OUT_539: usize = 1; -fn aiur_fn_539( - inp: [G; IN_539], +const INPUT_SIZE_565: usize = 3; +const IN_565: usize = 3; +const OUT_565: usize = 1; +fn aiur_fn_565( + inp: [G; IN_565], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_539], ExecError> { +) -> Result<[G; OUT_565], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_539] = [__v_6]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_565] = [__v_6]; + if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -46760,32 +48744,32 @@ fn aiur_fn_539( 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_539] = [__v_8]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_565] = [__v_8]; + if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_542(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_539] = [__v_5]; - if let Some(result) = record.function_queries[539].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_565] = [__v_5]; + if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_540: usize = 3; -const IN_540: usize = 3; -const OUT_540: usize = 1; -fn aiur_fn_540( - inp: [G; IN_540], +const INPUT_SIZE_566: usize = 3; +const IN_566: usize = 3; +const OUT_566: usize = 1; +fn aiur_fn_566( + inp: [G; IN_566], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_540], ExecError> { +) -> Result<[G; OUT_566], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46799,17 +48783,17 @@ fn aiur_fn_540( 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_540] = [__v_8]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_8]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_540(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_540] = [__v_7]; - if let Some(result) = record.function_queries[540].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_566] = [__v_7]; + if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46819,15 +48803,15 @@ fn aiur_fn_540( }) } -const INPUT_SIZE_541: usize = 4; -const IN_541: usize = 4; -const OUT_541: usize = 1; -fn aiur_fn_541( - inp: [G; IN_541], +const INPUT_SIZE_567: usize = 4; +const IN_567: usize = 4; +const OUT_567: usize = 1; +fn aiur_fn_567( + inp: [G; IN_567], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_541], ExecError> { +) -> Result<[G; OUT_567], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46844,12 +48828,12 @@ fn aiur_fn_541( 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_541] = [__v_11]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_567] = [__v_11]; + if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -46862,7 +48846,7 @@ fn aiur_fn_541( let __v_16: G = __r_arr[9]; let __v_17: G = __r_arr[10]; let __v_18: G = __r_arr[11]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __v_21: G = __r_arr[2]; @@ -46875,24 +48859,24 @@ fn aiur_fn_541( let __v_28: G = __r_arr[9]; let __v_29: G = __r_arr[10]; let __v_30: G = __r_arr[11]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_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_541] = [__v_34]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_567] = [__v_34]; + if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_541(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; let __v_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_541] = [__v_35]; - if let Some(result) = record.function_queries[541].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_567] = [__v_35]; + if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -46904,15 +48888,15 @@ fn aiur_fn_541( }) } -const INPUT_SIZE_542: usize = 3; -const IN_542: usize = 3; -const OUT_542: usize = 1; -fn aiur_fn_542( - inp: [G; IN_542], +const INPUT_SIZE_568: usize = 3; +const IN_568: usize = 3; +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_542], ExecError> { +) -> Result<[G; OUT_568], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46926,8 +48910,8 @@ fn aiur_fn_542( 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_542] = [__v_8]; - if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_568] = [__v_8]; + if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -46936,10 +48920,10 @@ fn aiur_fn_542( 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_543] = { let __args: [G; IN_543] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_542] = [__v_11]; - if let Some(result) = record.function_queries[542].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_568] = [__v_11]; + if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -46949,15 +48933,15 @@ fn aiur_fn_542( }) } -const INPUT_SIZE_543: usize = 5; -const IN_543: usize = 5; -const OUT_543: usize = 1; -fn aiur_fn_543( - inp: [G; IN_543], +const INPUT_SIZE_569: usize = 5; +const IN_569: usize = 5; +const OUT_569: usize = 1; +fn aiur_fn_569( + inp: [G; IN_569], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_543], ExecError> { +) -> Result<[G; OUT_569], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -46975,12 +48959,12 @@ fn aiur_fn_543( 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_543] = [__v_12]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_12]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -46993,7 +48977,7 @@ fn aiur_fn_543( let __v_17: G = __r_arr[9]; let __v_18: G = __r_arr[10]; let __v_19: G = __r_arr[11]; - let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_530(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -47006,17 +48990,17 @@ fn aiur_fn_543( let __v_29: G = __r_arr[9]; let __v_30: G = __r_arr[10]; let __v_31: G = __r_arr[11]; - let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_525(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __ret: [G; OUT_543] = [__v_35]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_35]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47026,11 +49010,11 @@ fn aiur_fn_543( 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_543] = { let __args: [G; IN_543] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_543(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; let __v_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_543] = [__v_41]; - if let Some(result) = record.function_queries[543].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_569] = [__v_41]; + if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47042,15 +49026,15 @@ fn aiur_fn_543( }) } -const INPUT_SIZE_544: usize = 2; -const IN_544: usize = 2; -const OUT_544: usize = 1; -fn aiur_fn_544( - inp: [G; IN_544], +const INPUT_SIZE_570: usize = 2; +const IN_570: usize = 2; +const OUT_570: usize = 1; +fn aiur_fn_570( + inp: [G; IN_570], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_544], ExecError> { +) -> Result<[G; OUT_570], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47067,14 +49051,14 @@ fn aiur_fn_544( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_544] = [__v_8]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_8]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_544] = [__v_8]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_8]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47087,25 +49071,25 @@ fn aiur_fn_544( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_544] = [__v_8]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_8]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_544] = [__v_9]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_9]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_544(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_544] = [__v_9]; - if let Some(result) = record.function_queries[544].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_570] = [__v_9]; + if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47122,15 +49106,15 @@ fn aiur_fn_544( }) } -const INPUT_SIZE_545: usize = 1; -const IN_545: usize = 1; -const OUT_545: usize = 1; -fn aiur_fn_545( - inp: [G; IN_545], +const INPUT_SIZE_571: usize = 1; +const IN_571: usize = 1; +const OUT_571: usize = 1; +fn aiur_fn_571( + inp: [G; IN_571], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_545], ExecError> { +) -> Result<[G; OUT_571], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -47142,17 +49126,17 @@ fn aiur_fn_545( 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_545] = [__v_6]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_571] = [__v_6]; + if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_545] = [__v_5]; - if let Some(result) = record.function_queries[545].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_571] = [__v_5]; + if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47162,15 +49146,15 @@ fn aiur_fn_545( }) } -const INPUT_SIZE_546: usize = 1; -const IN_546: usize = 1; -const OUT_546: usize = 1; -fn aiur_fn_546( - inp: [G; IN_546], +const INPUT_SIZE_572: usize = 1; +const IN_572: usize = 1; +const OUT_572: usize = 1; +fn aiur_fn_572( + inp: [G; IN_572], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_546], ExecError> { +) -> Result<[G; OUT_572], 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 }; @@ -47180,25 +49164,25 @@ fn aiur_fn_546( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_546] = [__v_4]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_4]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_546] = [__v_5]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_5]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_546] = [__v_5]; - if let Some(result) = record.function_queries[546].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_572] = [__v_5]; + if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47210,15 +49194,15 @@ fn aiur_fn_546( }) } -const INPUT_SIZE_547: usize = 2; -const IN_547: usize = 2; -const OUT_547: usize = 1; -fn aiur_fn_547( - inp: [G; IN_547], +const INPUT_SIZE_573: usize = 2; +const IN_573: usize = 2; +const OUT_573: usize = 1; +fn aiur_fn_573( + inp: [G; IN_573], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_547], ExecError> { +) -> Result<[G; OUT_573], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47275,26 +49259,26 @@ fn aiur_fn_547( 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_547] = [__v_51]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_51]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; match __v_3.as_canonical_u64() { 1u64 => { let __v_52: G = G::from_u64(0); let __v_53: G = { let __values: [G; 3] = [__v_52, __v_1, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_547] = [__v_53]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_53]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_547] = [__v_51]; - if let Some(result) = record.function_queries[547].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_573] = [__v_51]; + if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47306,15 +49290,15 @@ fn aiur_fn_547( }) } -const INPUT_SIZE_548: usize = 2; -const IN_548: usize = 2; -const OUT_548: usize = 1; -fn aiur_fn_548( - inp: [G; IN_548], +const INPUT_SIZE_574: usize = 2; +const IN_574: usize = 2; +const OUT_574: usize = 1; +fn aiur_fn_574( + inp: [G; IN_574], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_548], ExecError> { +) -> Result<[G; OUT_574], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47369,8 +49353,8 @@ fn aiur_fn_548( match __v_2.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_548] = [__v_49]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_574] = [__v_49]; + if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -47396,15 +49380,15 @@ fn aiur_fn_548( match __v_49.as_canonical_u64() { 1u64 => { let __v_50: G = G::from_u64(1); - let __ret: [G; OUT_548] = [__v_50]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_574] = [__v_50]; + if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_548] = [__v_50]; - if let Some(result) = record.function_queries[548].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_574] = [__v_50]; + if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47416,18 +49400,18 @@ fn aiur_fn_548( }) } -const INPUT_SIZE_549: usize = 1; -const IN_549: usize = 1; -const OUT_549: usize = 0; -fn aiur_fn_549( - inp: [G; IN_549], +const INPUT_SIZE_575: usize = 1; +const IN_575: usize = 1; +const OUT_575: usize = 0; +fn aiur_fn_575( + inp: [G; IN_575], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_549], ExecError> { +) -> Result<[G; OUT_575], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -47481,31 +49465,31 @@ fn aiur_fn_549( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_547(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(1); - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_2, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_548(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_2, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = (__v_52 * __v_54); let __v_56: G = G::from_u64(0); if (__v_55 != __v_56) { return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_56.as_canonical_u64(), msg: Some("mutual block mixes a definition member with inductives".to_string()) }); } - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = G::from_u64(2); let __v_59: G = { let __a_val = __v_57.as_canonical_u64(); let __b_val = __v_58.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_59.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_549] = []; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_273(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_295(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; let __v_61: G = G::from_u64(0); let __v_62: G = G::from_u64(1); @@ -47513,34 +49497,34 @@ fn aiur_fn_549( let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_65: G = { let __values: [G; 3] = [__v_61, __v_50, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_66: G = G::from_u64(1); - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = (__v_66 + __v_67); - let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_537(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_546(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = G::from_u64(1); if (__v_70 != __v_71) { return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_71.as_canonical_u64(), msg: Some("canonical block: refinement left members tied, order ambiguous".to_string()) }); } - let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_545(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_571(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_317(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_317] = unsafe { *(result.output.as_ptr() as *const [G; OUT_317]) }; __ret } } else { aiur_fn_317(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_72, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_339(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = G::from_u64(1); if (__v_73 != __v_74) { return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64(), msg: Some("canonical block: members are not in canonical order".to_string()) }); } - let __ret: [G; OUT_549] = []; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_549] = []; - if let Some(result) = record.function_queries[549].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_575] = []; + if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -47549,15 +49533,15 @@ fn aiur_fn_549( }) } -const INPUT_SIZE_550: usize = 12; -const IN_550: usize = 12; -const OUT_550: usize = 1; -fn aiur_fn_550( - inp: [G; IN_550], +const INPUT_SIZE_576: usize = 12; +const IN_576: usize = 12; +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_550], ExecError> { +) -> Result<[G; OUT_576], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47573,56 +49557,56 @@ fn aiur_fn_550( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_550] = [__v_3]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_3]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_4.as_canonical_u64() { 1u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_12]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_12]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 2u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_12]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_550] = [__v_4]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_4]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_550] = [__v_12]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_12]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_550] = [__v_6]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_6]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __ret: [G; OUT_550] = [__v_8]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_8]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_550] = [__v_9]; - if let Some(result) = record.function_queries[550].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_576] = [__v_9]; + if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47632,15 +49616,15 @@ fn aiur_fn_550( }) } -const INPUT_SIZE_551: usize = 1; -const IN_551: usize = 1; -const OUT_551: usize = 1; -fn aiur_fn_551( - inp: [G; IN_551], +const INPUT_SIZE_577: usize = 1; +const IN_577: usize = 1; +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_551], ExecError> { +) -> Result<[G; OUT_577], 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 }; @@ -47651,18 +49635,18 @@ fn aiur_fn_551( match __v_1.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_551] = [__v_5]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = [__v_5]; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_551] = [__v_5]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = [__v_5]; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -47678,67 +49662,67 @@ fn aiur_fn_551( let __v_16: G = __loaded[10]; let __v_17: G = __loaded[11]; let __v_18: G = G::from_u64(1); - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__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[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__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[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); - let __ret: [G; OUT_551] = [__v_20]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = [__v_20]; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_551] = [__v_7]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = [__v_7]; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_551] = [__v_7]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = [__v_7]; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = (__v_5 * __v_6); - let __ret: [G; OUT_551] = [__v_7]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = [__v_7]; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = (__v_6 * __v_7); let __v_9: G = (__v_5 * __v_8); - let __ret: [G; OUT_551] = [__v_9]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = [__v_9]; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_551] = [__v_5]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = [__v_5]; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_551] = [__v_5]; - if let Some(result) = record.function_queries[551].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_577] = [__v_5]; + if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47748,48 +49732,48 @@ fn aiur_fn_551( }) } -const INPUT_SIZE_552: usize = 2; -const IN_552: usize = 2; -const OUT_552: usize = 0; -fn aiur_fn_552( - inp: [G; IN_552], +const INPUT_SIZE_578: usize = 2; +const IN_578: usize = 2; +const OUT_578: usize = 0; +fn aiur_fn_578( + inp: [G; IN_578], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_552], ExecError> { +) -> Result<[G; OUT_578], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_552] = []; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_578] = []; + if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_551(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = G::from_u64(1); if (__v_2 != __v_3) { return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("safe constant references an unsafe constant".to_string()) }); } - let __ret: [G; OUT_552] = []; - if let Some(result) = record.function_queries[552].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_578] = []; + if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_553: usize = 2; -const IN_553: usize = 2; -const OUT_553: usize = 0; -fn aiur_fn_553( - inp: [G; IN_553], +const INPUT_SIZE_579: usize = 2; +const IN_579: usize = 2; +const OUT_579: usize = 0; +fn aiur_fn_579( + inp: [G; IN_579], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_553], ExecError> { +) -> Result<[G; OUT_579], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47799,28 +49783,28 @@ fn aiur_fn_553( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_553] = []; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_579] = []; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_553] = []; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_579] = []; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_553] = []; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_579] = []; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_553] = []; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_579] = []; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { @@ -47829,8 +49813,8 @@ fn aiur_fn_553( if (__v_5 != __v_6) { return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("universe param index out of range".to_string()) }); } - let __ret: [G; OUT_553] = []; - if let Some(result) = record.function_queries[553].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_579] = []; + if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47840,15 +49824,15 @@ fn aiur_fn_553( }) } -const INPUT_SIZE_554: usize = 2; -const IN_554: usize = 2; -const OUT_554: usize = 0; -fn aiur_fn_554( - inp: [G; IN_554], +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_554], ExecError> { +) -> Result<[G; OUT_580], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47858,15 +49842,15 @@ fn aiur_fn_554( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_554] = []; - if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_554(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_554] = []; - if let Some(result) = record.function_queries[554].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_580] = []; + if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47876,15 +49860,15 @@ fn aiur_fn_554( }) } -const INPUT_SIZE_555: usize = 3; -const IN_555: usize = 3; -const OUT_555: usize = 0; -fn aiur_fn_555( - inp: [G; IN_555], +const INPUT_SIZE_581: usize = 3; +const IN_581: usize = 3; +const OUT_581: usize = 0; +fn aiur_fn_581( + inp: [G; IN_581], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_555], ExecError> { +) -> Result<[G; OUT_581], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -47901,18 +49885,18 @@ fn aiur_fn_555( if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("loose bound variable: BVar index exceeds binder depth".to_string()) }); } - let __ret: [G; OUT_555] = []; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_581] = []; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_553(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_555] = []; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_581] = []; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -47927,62 +49911,62 @@ fn aiur_fn_555( let __v_17: G = __loaded[9]; let __v_18: G = __loaded[10]; let __v_19: G = __loaded[11]; - let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_406(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_431(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; if (__v_21 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) }); } - let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_554(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_555] = []; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_581] = []; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_555] = []; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_581] = []; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_555] = []; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_581] = []; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_555] = []; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_581] = []; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_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 !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_555] = []; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_581] = []; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __ret: [G; OUT_555] = []; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_581] = []; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_555] = []; - if let Some(result) = record.function_queries[555].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_581] = []; + if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -47992,15 +49976,15 @@ fn aiur_fn_555( }) } -const INPUT_SIZE_556: usize = 0; -const IN_556: usize = 0; -const OUT_556: usize = 1; -fn aiur_fn_556( - inp: [G; IN_556], +const INPUT_SIZE_582: usize = 0; +const IN_582: usize = 0; +const OUT_582: usize = 1; +fn aiur_fn_582( + inp: [G; IN_582], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_556], ExecError> { +) -> Result<[G; OUT_582], 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); @@ -48035,21 +50019,21 @@ fn aiur_fn_556( 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_556] = [__v_32]; - if let Some(result) = record.function_queries[556].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_582] = [__v_32]; + if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_557: usize = 3; -const IN_557: usize = 3; -const OUT_557: usize = 1; -fn aiur_fn_557( - inp: [G; IN_557], +const INPUT_SIZE_583: usize = 3; +const IN_583: usize = 3; +const OUT_583: usize = 1; +fn aiur_fn_583( + inp: [G; IN_583], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_557], ExecError> { +) -> Result<[G; OUT_583], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48058,8 +50042,8 @@ fn aiur_fn_557( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_557] = [__v_4]; - if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_583] = [__v_4]; + if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48072,16 +50056,16 @@ fn aiur_fn_557( 5u64 => { 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_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_557] = [__v_10]; - if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_583] = [__v_10]; + if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_557] = [__v_8]; - if let Some(result) = record.function_queries[557].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_583] = [__v_8]; + if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48090,15 +50074,15 @@ fn aiur_fn_557( }) } -const INPUT_SIZE_558: usize = 0; -const IN_558: usize = 0; -const OUT_558: usize = 0; -fn aiur_fn_558( - inp: [G; IN_558], +const INPUT_SIZE_584: usize = 0; +const IN_584: usize = 0; +const OUT_584: usize = 0; +fn aiur_fn_584( + inp: [G; IN_584], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_558], ExecError> { +) -> Result<[G; OUT_584], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = G::from_u64(3); let __v_1: G = G::from_u64(107); @@ -48133,7 +50117,7 @@ fn aiur_fn_558( let __v_30: G = G::from_u64(224); let __v_31: G = G::from_u64(201); let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_34: G = __loaded[0]; @@ -48162,8 +50146,8 @@ fn aiur_fn_558( if (__v_39 != __v_48) { return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_48.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) }); } - let __ret: [G; OUT_558] = []; - if let Some(result) = record.function_queries[558].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_584] = []; + if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48173,15 +50157,15 @@ fn aiur_fn_558( }) } -const INPUT_SIZE_559: usize = 4; -const IN_559: usize = 4; -const OUT_559: usize = 0; -fn aiur_fn_559( - inp: [G; IN_559], +const INPUT_SIZE_585: usize = 4; +const IN_585: usize = 4; +const OUT_585: usize = 0; +fn aiur_fn_585( + inp: [G; IN_585], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_559], ExecError> { +) -> Result<[G; OUT_585], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48189,7 +50173,7 @@ fn aiur_fn_559( let __v_3: G = inp[3]; let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[556].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_556(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_556] = unsafe { *(result.output.as_ptr() as *const [G; OUT_556]) }; __ret } } else { aiur_fn_556(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -48202,7 +50186,7 @@ fn aiur_fn_559( break '__mc_0 [__v_7, __v_8]; }, 1u64 => { - let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_358(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_383(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -48215,8 +50199,8 @@ fn aiur_fn_559( break '__mc_0 [__v_7, __v_8]; }, 2u64 => { - let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_558(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_384(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -48229,7 +50213,7 @@ fn aiur_fn_559( break '__mc_0 [__v_7, __v_8]; }, 3u64 => { - let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_360(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_385(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; @@ -48252,34 +50236,34 @@ fn aiur_fn_559( return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Quot constant: wrong universe param count for its kind".to_string()) }); } let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_557(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); if (__v_7 != __v_8) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Quot constant: type has too few foralls for its kind".to_string()) }); } - let __ret: [G; OUT_559] = []; - if let Some(result) = record.function_queries[559].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_585] = []; + if let Some(result) = record.function_queries[585].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_560: usize = 2; -const IN_560: usize = 2; -const OUT_560: usize = 1; -fn aiur_fn_560( - inp: [G; IN_560], +const INPUT_SIZE_586: usize = 2; +const IN_586: usize = 2; +const OUT_586: usize = 1; +fn aiur_fn_586( + inp: [G; IN_586], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_560], ExecError> { +) -> Result<[G; OUT_586], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_560] = [__v_0]; - if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_586] = [__v_0]; + if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48292,10 +50276,10 @@ fn aiur_fn_560( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_560] = [__v_8]; - if let Some(result) = record.function_queries[560].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_586] = [__v_8]; + if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48307,29 +50291,29 @@ fn aiur_fn_560( }) } -const INPUT_SIZE_561: usize = 3; -const IN_561: usize = 3; -const OUT_561: usize = 0; -fn aiur_fn_561( - inp: [G; IN_561], +const INPUT_SIZE_587: usize = 3; +const IN_587: usize = 3; +const OUT_587: usize = 0; +fn aiur_fn_587( + inp: [G; IN_587], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_561], ExecError> { +) -> Result<[G; OUT_587], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(0); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("more universe levels than the inductive declares".to_string()) }); } - let __ret: [G; OUT_561] = []; - if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_587] = []; + if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48349,12 +50333,12 @@ fn aiur_fn_561( 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_561] = { let __args: [G; IN_561] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; if (__v_7 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return type: universe level is not Param(i) in order".to_string()) }); } - let __ret: [G; OUT_561] = []; - if let Some(result) = record.function_queries[561].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_587] = []; + if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48371,15 +50355,15 @@ fn aiur_fn_561( }) } -const INPUT_SIZE_562: usize = 4; -const IN_562: usize = 4; -const OUT_562: usize = 0; -fn aiur_fn_562( - inp: [G; IN_562], +const INPUT_SIZE_588: usize = 4; +const IN_588: usize = 4; +const OUT_588: usize = 0; +fn aiur_fn_588( + inp: [G; IN_588], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_562], ExecError> { +) -> Result<[G; OUT_588], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48388,8 +50372,8 @@ fn aiur_fn_562( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_562] = []; - if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_588] = []; + if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48408,7 +50392,7 @@ fn aiur_fn_562( 0u64 => { let __v_12: G = G::from_u64(1); let __v_13: G = (__v_3 + __v_12); - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_7, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; let __v_14: G = (__v_2 + __v_1); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_14 - __v_15); @@ -48416,8 +50400,8 @@ fn aiur_fn_562( if (__v_9 != __v_17) { return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return type: param arg is not the expected param BVar".to_string()) }); } - let __ret: [G; OUT_562] = []; - if let Some(result) = record.function_queries[562].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_588] = []; + if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48434,20 +50418,20 @@ fn aiur_fn_562( }) } -const INPUT_SIZE_563: usize = 3; -const IN_563: usize = 3; -const OUT_563: usize = 0; -fn aiur_fn_563( - inp: [G; IN_563], +const INPUT_SIZE_589: usize = 3; +const IN_589: usize = 3; +const OUT_589: usize = 0; +fn aiur_fn_589( + inp: [G; IN_589], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_563], ExecError> { +) -> Result<[G; OUT_589], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -48473,8 +50457,8 @@ fn aiur_fn_563( if (__v_12 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return head is a different member of the block".to_string()) }); } - let __ret: [G; OUT_563] = []; - if let Some(result) = record.function_queries[563].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_589] = []; + if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48484,15 +50468,15 @@ fn aiur_fn_563( }) } -const INPUT_SIZE_564: usize = 7; -const IN_564: usize = 7; -const OUT_564: usize = 0; -fn aiur_fn_564( - inp: [G; IN_564], +const INPUT_SIZE_590: usize = 7; +const IN_590: usize = 7; +const OUT_590: usize = 0; +fn aiur_fn_590( + inp: [G; IN_590], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_564], ExecError> { +) -> Result<[G; OUT_590], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48502,7 +50486,7 @@ fn aiur_fn_564( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = (__v_1 + __v_3); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; @@ -48514,32 +50498,32 @@ fn aiur_fn_564( let __v_14: G = __loaded[3]; match __v_11.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_563(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_562(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_10, __v_1, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_22: G = { let __values: [G; 3] = [__v_18, __v_5, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = (__v_1 + __v_2); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) }); } - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_17, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); if (__v_25 != __v_26) { return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) }); } - let __ret: [G; OUT_564] = []; - if let Some(result) = record.function_queries[564].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_590] = []; + if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48549,15 +50533,15 @@ fn aiur_fn_564( }) } -const INPUT_SIZE_565: usize = 4; -const IN_565: usize = 4; -const OUT_565: usize = 0; -fn aiur_fn_565( - inp: [G; IN_565], +const INPUT_SIZE_591: usize = 4; +const IN_591: usize = 4; +const OUT_591: usize = 0; +fn aiur_fn_591( + inp: [G; IN_591], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_565], ExecError> { +) -> Result<[G; OUT_591], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48565,8 +50549,8 @@ fn aiur_fn_565( let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_565] = []; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_591] = []; + if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48584,7 +50568,7 @@ fn aiur_fn_565( let __v_11: G = __loaded[3]; match __v_8.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_13, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; @@ -48594,9 +50578,9 @@ fn aiur_fn_565( } let __v_16: G = G::from_u64(1); let __v_17: G = (__v_2 - __v_16); - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_565] = []; - if let Some(result) = record.function_queries[565].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_10, __v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_591] = []; + if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48613,15 +50597,15 @@ fn aiur_fn_565( }) } -const INPUT_SIZE_566: usize = 3; -const IN_566: usize = 3; -const OUT_566: usize = 0; -fn aiur_fn_566( - inp: [G; IN_566], +const INPUT_SIZE_592: usize = 3; +const IN_592: usize = 3; +const OUT_592: usize = 0; +fn aiur_fn_592( + inp: [G; IN_592], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_566], ExecError> { +) -> Result<[G; OUT_592], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48629,27 +50613,27 @@ fn aiur_fn_566( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_565(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_566] = []; - if let Some(result) = record.function_queries[566].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_592] = []; + if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_567: usize = 3; -const IN_567: usize = 3; -const OUT_567: usize = 1; -fn aiur_fn_567( - inp: [G; IN_567], +const INPUT_SIZE_593: usize = 3; +const IN_593: usize = 3; +const OUT_593: usize = 1; +fn aiur_fn_593( + inp: [G; IN_593], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_567], ExecError> { +) -> Result<[G; OUT_593], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; match __v_1.as_canonical_u64() { 0u64 => { @@ -48660,8 +50644,8 @@ fn aiur_fn_567( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_567] = [__v_5]; - if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_593] = [__v_5]; + if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48681,10 +50665,10 @@ fn aiur_fn_567( let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_567] = [__v_12]; - if let Some(result) = record.function_queries[567].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_593] = [__v_12]; + if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48696,15 +50680,15 @@ fn aiur_fn_567( }) } -const INPUT_SIZE_568: usize = 3; -const IN_568: usize = 3; -const OUT_568: usize = 0; -fn aiur_fn_568( - inp: [G; IN_568], +const INPUT_SIZE_594: usize = 3; +const IN_594: usize = 3; +const OUT_594: usize = 0; +fn aiur_fn_594( + inp: [G; IN_594], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_568], ExecError> { +) -> Result<[G; OUT_594], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48716,9 +50700,9 @@ fn aiur_fn_568( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_301(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_323(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); if (__v_8 != __v_9) { @@ -48726,29 +50710,29 @@ fn aiur_fn_568( } let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_568] = []; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_594] = []; + if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_568] = []; - if let Some(result) = record.function_queries[568].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_594] = []; + if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_569: usize = 4; -const IN_569: usize = 4; -const OUT_569: usize = 0; -fn aiur_fn_569( - inp: [G; IN_569], +const INPUT_SIZE_595: usize = 4; +const IN_595: usize = 4; +const OUT_595: usize = 0; +fn aiur_fn_595( + inp: [G; IN_595], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_569], ExecError> { +) -> Result<[G; OUT_595], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48756,9 +50740,9 @@ fn aiur_fn_569( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_568(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_569] = []; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_595] = []; + if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48773,9 +50757,9 @@ fn aiur_fn_569( let __v_9: G = (__v_1 - __v_8); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_569] = []; - if let Some(result) = record.function_queries[569].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_595] = []; + if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -48787,15 +50771,15 @@ fn aiur_fn_569( }) } -const INPUT_SIZE_570: usize = 3; -const IN_570: usize = 3; -const OUT_570: usize = 0; -fn aiur_fn_570( - inp: [G; IN_570], +const INPUT_SIZE_596: usize = 3; +const IN_596: usize = 3; +const OUT_596: usize = 0; +fn aiur_fn_596( + inp: [G; IN_596], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_570], ExecError> { +) -> Result<[G; OUT_596], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48806,52 +50790,52 @@ fn aiur_fn_570( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_570] = []; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_596] = []; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_569(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_570] = []; - if let Some(result) = record.function_queries[570].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_596] = []; + if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_571: usize = 2; -const IN_571: usize = 2; -const OUT_571: usize = 1; -fn aiur_fn_571( - inp: [G; IN_571], +const INPUT_SIZE_597: usize = 2; +const IN_597: usize = 2; +const OUT_597: usize = 1; +fn aiur_fn_597( + inp: [G; IN_597], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_571], ExecError> { +) -> Result<[G; OUT_597], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __ret: [G; OUT_571] = [__v_2]; - if let Some(result) = record.function_queries[571].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_597] = [__v_2]; + if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_572: usize = 2; -const IN_572: usize = 2; -const OUT_572: usize = 1; -fn aiur_fn_572( - inp: [G; IN_572], +const INPUT_SIZE_598: usize = 2; +const IN_598: usize = 2; +const OUT_598: usize = 1; +fn aiur_fn_598( + inp: [G; IN_598], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_572], ExecError> { +) -> Result<[G; OUT_598], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48862,8 +50846,8 @@ fn aiur_fn_572( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_572] = [__v_5]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_5]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -48872,15 +50856,15 @@ fn aiur_fn_572( match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_572] = [__v_6]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_6]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_572] = [__v_6]; - if let Some(result) = record.function_queries[572].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_598] = [__v_6]; + if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -48892,19 +50876,19 @@ fn aiur_fn_572( }) } -const INPUT_SIZE_573: usize = 2; -const IN_573: usize = 2; -const OUT_573: usize = 1; -fn aiur_fn_573( - inp: [G; IN_573], +const INPUT_SIZE_599: usize = 2; +const IN_599: usize = 2; +const OUT_599: usize = 1; +fn aiur_fn_599( + inp: [G; IN_599], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_573], ExecError> { +) -> Result<[G; OUT_599], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -48921,31 +50905,31 @@ fn aiur_fn_573( let __v_14: G = __loaded[11]; match __v_3.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_572(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_573] = [__v_15]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_599] = [__v_15]; + if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); - let __ret: [G; OUT_573] = [__v_15]; - if let Some(result) = record.function_queries[573].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_599] = [__v_15]; + if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_574: usize = 2; -const IN_574: usize = 2; -const OUT_574: usize = 1; -fn aiur_fn_574( - inp: [G; IN_574], +const INPUT_SIZE_600: usize = 2; +const IN_600: usize = 2; +const OUT_600: usize = 1; +fn aiur_fn_600( + inp: [G; IN_600], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_574], ExecError> { +) -> Result<[G; OUT_600], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -48957,105 +50941,105 @@ fn aiur_fn_574( match __v_2.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_574] = [__v_6]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_6]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_574] = [__v_6]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_6]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_6]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_6]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_574] = [__v_7]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_7]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 4u64 => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_574] = [__v_7]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_7]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 5u64 => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_574] = [__v_7]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_7]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 6u64 => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_574] = [__v_7]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_7]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; match __v_7.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_574] = [__v_8]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_8]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_8]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_8]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49064,15 +51048,15 @@ fn aiur_fn_574( }, 7u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_574] = [__v_6]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_6]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_574] = [__v_6]; - if let Some(result) = record.function_queries[574].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_600] = [__v_6]; + if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49082,15 +51066,15 @@ fn aiur_fn_574( }) } -const INPUT_SIZE_575: usize = 2; -const IN_575: usize = 2; -const OUT_575: usize = 1; -fn aiur_fn_575( - inp: [G; IN_575], +const INPUT_SIZE_601: usize = 2; +const IN_601: usize = 2; +const OUT_601: usize = 1; +fn aiur_fn_601( + inp: [G; IN_601], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_575], ExecError> { +) -> Result<[G; OUT_601], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49101,25 +51085,25 @@ fn aiur_fn_575( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_575] = [__v_5]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_601] = [__v_5]; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_575] = [__v_6]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_601] = [__v_6]; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_575] = [__v_6]; - if let Some(result) = record.function_queries[575].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_601] = [__v_6]; + if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49131,23 +51115,23 @@ fn aiur_fn_575( }) } -const INPUT_SIZE_576: usize = 3; -const IN_576: usize = 3; -const OUT_576: usize = 2; -fn aiur_fn_576( - inp: [G; IN_576], +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_576], ExecError> { +) -> Result<[G; OUT_602], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_576] = [__v_0, __v_2]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_602] = [__v_0, __v_2]; + if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49162,16 +51146,16 @@ fn aiur_fn_576( 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_576] = { let __args: [G; IN_576] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_576] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_602] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_576] = [__v_0, __v_2]; - if let Some(result) = record.function_queries[576].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_602] = [__v_0, __v_2]; + if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49180,15 +51164,15 @@ fn aiur_fn_576( }) } -const INPUT_SIZE_577: usize = 4; -const IN_577: usize = 4; -const OUT_577: usize = 0; -fn aiur_fn_577( - inp: [G; IN_577], +const INPUT_SIZE_603: usize = 4; +const IN_603: usize = 4; +const OUT_603: usize = 0; +fn aiur_fn_603( + inp: [G; IN_603], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_577], ExecError> { +) -> Result<[G; OUT_603], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49197,8 +51181,8 @@ fn aiur_fn_577( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_603] = []; + if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49223,9 +51207,9 @@ fn aiur_fn_577( } let __v_15: G = G::from_u64(1); let __v_16: G = (__v_3 + __v_15); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_577] = []; - if let Some(result) = record.function_queries[577].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_603] = []; + if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49242,22 +51226,22 @@ fn aiur_fn_577( }) } -const INPUT_SIZE_578: usize = 5; -const IN_578: usize = 5; -const OUT_578: usize = 0; -fn aiur_fn_578( - inp: [G; IN_578], +const INPUT_SIZE_604: usize = 5; +const IN_604: usize = 5; +const OUT_604: usize = 0; +fn aiur_fn_604( + inp: [G; IN_604], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_578], ExecError> { +) -> Result<[G; OUT_604], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_6: G = __loaded[0]; @@ -49275,25 +51259,25 @@ fn aiur_fn_578( match __v_6.as_canonical_u64() { 5u64 => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_561(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[577].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_577(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_577] = unsafe { *(result.output.as_ptr() as *const [G; OUT_577]) }; __ret } } else { aiur_fn_577(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_2, __v_9, __v_4, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = (__v_9 + __v_10); if (__v_20 != __v_21) { return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("recursive occurrence is not fully applied".to_string()) }); } - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_22, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); if (__v_23 != __v_24) { return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_24.as_canonical_u64(), msg: Some("recursive occurrence: index argument mentions the block".to_string()) }); } - let __ret: [G; OUT_578] = []; - if let Some(result) = record.function_queries[578].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_604] = []; + if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49303,30 +51287,30 @@ fn aiur_fn_578( }) } -const INPUT_SIZE_579: usize = 4; -const IN_579: usize = 4; -const OUT_579: usize = 0; -fn aiur_fn_579( - inp: [G; IN_579], +const INPUT_SIZE_605: usize = 4; +const IN_605: usize = 4; +const OUT_605: usize = 0; +fn aiur_fn_605( + inp: [G; IN_605], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_579], ExecError> { +) -> Result<[G; OUT_605], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -49337,15 +51321,15 @@ fn aiur_fn_579( 5u64 => { let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_574(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); if (__v_12 != __v_13) { return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("strict positivity: block occurs left of an arrow".to_string()) }); } - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_8, __v_1, __v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49359,28 +51343,28 @@ fn aiur_fn_579( let __v_15: G = __loaded[3]; match __v_12.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_573(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { match __v_3.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_18: G = __loaded[0]; @@ -49397,24 +51381,24 @@ fn aiur_fn_579( let __v_29: G = __loaded[11]; match __v_18.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = { let __values: [G; 3] = [__v_31, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(0); if (__v_35 != __v_36) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64(), msg: Some("strict positivity: block occurs in a nested inductive's index args".to_string()) }); } let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_579] = []; - if let Some(result) = record.function_queries[579].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_25, __v_26, __v_23, __v_32, __v_37, __v_21, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_605] = []; + if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49435,15 +51419,15 @@ fn aiur_fn_579( }) } -const INPUT_SIZE_580: usize = 7; -const IN_580: usize = 7; -const OUT_580: usize = 0; -fn aiur_fn_580( - inp: [G; IN_580], +const INPUT_SIZE_606: usize = 7; +const IN_606: usize = 7; +const OUT_606: usize = 0; +fn aiur_fn_606( + inp: [G; IN_606], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_580], ExecError> { +) -> Result<[G; OUT_606], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49455,12 +51439,12 @@ fn aiur_fn_580( let __v_7: G = (__v_2 - __v_4); match __v_7.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_606] = []; + if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -49480,22 +51464,22 @@ fn aiur_fn_580( let __v_21: G = G::from_u64(1); let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_372(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = G::from_u64(1); let __v_29: G = G::from_u64(1); let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; let __v_32: G = G::from_u64(1); let __v_33: G = (__v_4 + __v_32); - let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_580(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_580] = []; - if let Some(result) = record.function_queries[580].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_606] = []; + if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49507,15 +51491,15 @@ fn aiur_fn_580( }) } -const INPUT_SIZE_581: usize = 4; -const IN_581: usize = 4; -const OUT_581: usize = 0; -fn aiur_fn_581( - inp: [G; IN_581], +const INPUT_SIZE_607: usize = 4; +const IN_607: usize = 4; +const OUT_607: usize = 0; +fn aiur_fn_607( + inp: [G; IN_607], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_581], ExecError> { +) -> Result<[G; OUT_607], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49528,32 +51512,32 @@ fn aiur_fn_581( let __v_7: G = __loaded[3]; match __v_4.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_579(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_607] = []; + if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_581] = []; - if let Some(result) = record.function_queries[581].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_607] = []; + if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_582: usize = 4; -const IN_582: usize = 4; -const OUT_582: usize = 0; -fn aiur_fn_582( - inp: [G; IN_582], +const INPUT_SIZE_608: usize = 4; +const IN_608: usize = 4; +const OUT_608: usize = 0; +fn aiur_fn_608( + inp: [G; IN_608], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_582], ExecError> { +) -> Result<[G; OUT_608], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49564,26 +51548,26 @@ fn aiur_fn_582( let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_8: G = { let __values: [G; 3] = [__v_4, __v_2, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_602(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = __r_arr[1]; let __v_11: G = G::from_u64(1); - let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_582] = []; - if let Some(result) = record.function_queries[582].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_608] = []; + if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_583: usize = 8; -const IN_583: usize = 8; -const OUT_583: usize = 0; -fn aiur_fn_583( - inp: [G; IN_583], +const INPUT_SIZE_609: usize = 8; +const IN_609: usize = 8; +const OUT_609: usize = 0; +fn aiur_fn_609( + inp: [G; IN_609], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_583], ExecError> { +) -> Result<[G; OUT_609], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49597,25 +51581,25 @@ fn aiur_fn_583( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_583] = []; - if let Some(result) = record.function_queries[583].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_609] = []; + if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_584: usize = 10; -const IN_584: usize = 10; -const OUT_584: usize = 0; -fn aiur_fn_584( - inp: [G; IN_584], +const INPUT_SIZE_610: usize = 10; +const IN_610: usize = 10; +const OUT_610: usize = 0; +fn aiur_fn_610( + inp: [G; IN_610], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_584], ExecError> { +) -> Result<[G; OUT_610], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49630,12 +51614,12 @@ fn aiur_fn_584( let __v_10: G = (__v_3 - __v_9); match __v_10.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_584] = []; - if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_610] = []; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_12: G = __loaded[0]; @@ -49652,15 +51636,15 @@ fn aiur_fn_584( let __v_23: G = __loaded[11]; match __v_12.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() { 0u64 => { let __v_24: G = G::from_u64(1); let __v_25: G = G::from_u64(1); let __v_26: G = { let __values: [G; 3] = [__v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_14, __v_18, __v_5, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -49685,9 +51669,9 @@ fn aiur_fn_584( } let __v_26: G = G::from_u64(1); let __v_27: G = (__v_9 + __v_26); - let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_584(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_584] = []; - if let Some(result) = record.function_queries[584].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_610] = []; + if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -49699,15 +51683,15 @@ fn aiur_fn_584( }) } -const INPUT_SIZE_585: usize = 12; -const IN_585: usize = 12; -const OUT_585: usize = 0; -fn aiur_fn_585( - inp: [G; IN_585], +const INPUT_SIZE_611: usize = 12; +const IN_611: usize = 12; +const OUT_611: usize = 0; +fn aiur_fn_611( + inp: [G; IN_611], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_585], ExecError> { +) -> Result<[G; OUT_611], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49723,29 +51707,29 @@ fn aiur_fn_585( let __v_11: G = inp[11]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_585] = []; - if let Some(result) = record.function_queries[585].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_611] = []; + if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_585] = []; - if let Some(result) = record.function_queries[585].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_611] = []; + if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_586: usize = 13; -const IN_586: usize = 13; -const OUT_586: usize = 0; -fn aiur_fn_586( - inp: [G; IN_586], +const INPUT_SIZE_612: usize = 13; +const IN_612: usize = 13; +const OUT_612: usize = 0; +fn aiur_fn_612( + inp: [G; IN_612], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_586], ExecError> { +) -> Result<[G; OUT_612], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49766,12 +51750,12 @@ fn aiur_fn_586( let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_586] = []; - if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = []; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; @@ -49825,14 +51809,14 @@ fn aiur_fn_586( match __v_14.as_canonical_u64() { 8u64 => { let __v_62: G = G::from_u64(0); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_586] = []; - if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_612] = []; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_586] = []; - if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = []; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49842,23 +51826,23 @@ fn aiur_fn_586( } }, _ => { - let __ret: [G; OUT_586] = []; - if let Some(result) = record.function_queries[586].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_612] = []; + if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_587: usize = 7; -const IN_587: usize = 7; -const OUT_587: usize = 0; -fn aiur_fn_587( - inp: [G; IN_587], +const INPUT_SIZE_613: usize = 7; +const IN_613: usize = 7; +const OUT_613: usize = 0; +fn aiur_fn_613( + inp: [G; IN_613], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_587], ExecError> { +) -> Result<[G; OUT_613], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -49917,8 +51901,8 @@ fn aiur_fn_587( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_613] = []; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -49930,13 +51914,13 @@ fn aiur_fn_587( 1u64 => { let __v_56: G = G::from_u64(1); let __v_57: G = (__v_5 + __v_56); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_613] = []; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; @@ -49953,23 +51937,23 @@ fn aiur_fn_587( let __v_68: G = __loaded[11]; match __v_57.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; let __v_69: G = (__v_2 + __v_3); let __v_70: G = G::from_u64(1); let __v_71: G = G::from_u64(1); let __v_72: G = { let __values: [G; 3] = [__v_70, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_60 + __v_61); let __v_75: G = G::from_u64(1); let __v_76: G = G::from_u64(1); let __v_77: G = { let __values: [G; 3] = [__v_75, __v_76, __v_76]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; if (__v_60 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) }); } - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_73, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = G::from_u64(1); if (__v_79 != __v_80) { @@ -49977,17 +51961,17 @@ fn aiur_fn_587( } let __v_81: G = G::from_u64(1); let __v_82: G = (__v_5 + __v_81); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_613] = []; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_69: G = G::from_u64(1); let __v_70: G = (__v_5 + __v_69); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_613] = []; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -49997,9 +51981,9 @@ fn aiur_fn_587( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_5 + __v_54); - let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_587(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_587] = []; - if let Some(result) = record.function_queries[587].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_613] = []; + if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50011,15 +51995,15 @@ fn aiur_fn_587( }) } -const INPUT_SIZE_588: usize = 16; -const IN_588: usize = 16; -const OUT_588: usize = 1; -fn aiur_fn_588( - inp: [G; IN_588], +const INPUT_SIZE_614: usize = 16; +const IN_614: usize = 16; +const OUT_614: usize = 1; +fn aiur_fn_614( + inp: [G; IN_614], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_588], ExecError> { +) -> Result<[G; OUT_614], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50037,37 +52021,37 @@ fn aiur_fn_588( let __v_13: G = inp[13]; let __v_14: G = inp[14]; let __v_15: G = inp[15]; - let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_275(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_275] = unsafe { *(result.output.as_ptr() as *const [G; OUT_275]) }; __ret } } else { aiur_fn_275(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_297(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_588] = [__v_17]; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_15.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_588] = [__v_17]; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_1.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_588] = [__v_17]; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { match __v_2.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_588] = [__v_17]; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50076,26 +52060,26 @@ fn aiur_fn_588( match __v_10.as_canonical_u64() { 0u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_588] = [__v_17]; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = G::from_u64(1); let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_588] = [__v_20]; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_20]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_588] = [__v_17]; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50104,8 +52088,8 @@ fn aiur_fn_588( }, _ => { let __v_17: G = G::from_u64(0); - let __ret: [G; OUT_588] = [__v_17]; - if let Some(result) = record.function_queries[588].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_614] = [__v_17]; + if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50116,15 +52100,15 @@ fn aiur_fn_588( }) } -const INPUT_SIZE_589: usize = 4; -const IN_589: usize = 4; -const OUT_589: usize = 1; -fn aiur_fn_589( - inp: [G; IN_589], +const INPUT_SIZE_615: usize = 4; +const IN_615: usize = 4; +const OUT_615: usize = 1; +fn aiur_fn_615( + inp: [G; IN_615], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_589], ExecError> { +) -> Result<[G; OUT_615], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50136,10 +52120,10 @@ fn aiur_fn_589( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_589] = [__v_8]; - if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_8]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50154,16 +52138,16 @@ fn aiur_fn_589( let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = G::from_u64(1); let __v_11: G = (__v_1 - __v_10); - let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_589(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_589] = [__v_12]; - if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_12]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_589] = [__v_8]; - if let Some(result) = record.function_queries[589].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_615] = [__v_8]; + if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50172,15 +52156,15 @@ fn aiur_fn_589( }) } -const INPUT_SIZE_590: usize = 5; -const IN_590: usize = 5; -const OUT_590: usize = 1; -fn aiur_fn_590( - inp: [G; IN_590], +const INPUT_SIZE_616: usize = 5; +const IN_616: usize = 5; +const OUT_616: usize = 1; +fn aiur_fn_616( + inp: [G; IN_616], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_590], ExecError> { +) -> Result<[G; OUT_616], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50193,10 +52177,10 @@ fn aiur_fn_590( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_590] = [__v_8]; - if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_8]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50207,13 +52191,13 @@ fn aiur_fn_590( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_7, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(0); let __v_13: G = G::from_u64(0); let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = (__v_11 - __v_15); let __v_17: G = G::from_u64(1); @@ -50235,16 +52219,16 @@ fn aiur_fn_590( let __v_22: G = { let __values: [G; 3] = [__v_21, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = G::from_u64(1); let __v_24: G = (__v_2 + __v_23); - let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_590] = [__v_25]; - if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_25]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_590] = [__v_10]; - if let Some(result) = record.function_queries[590].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_616] = [__v_10]; + if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50253,15 +52237,15 @@ fn aiur_fn_590( }) } -const INPUT_SIZE_591: usize = 2; -const IN_591: usize = 2; -const OUT_591: usize = 1; -fn aiur_fn_591( - inp: [G; IN_591], +const INPUT_SIZE_617: usize = 2; +const IN_617: usize = 2; +const OUT_617: usize = 1; +fn aiur_fn_617( + inp: [G; IN_617], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_591], ExecError> { +) -> Result<[G; OUT_617], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50272,25 +52256,25 @@ fn aiur_fn_591( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_591] = [__v_5]; - if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_617] = [__v_5]; + if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_591] = [__v_6]; - if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_617] = [__v_6]; + if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_591(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_591] = [__v_6]; - if let Some(result) = record.function_queries[591].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_617] = [__v_6]; + if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50302,15 +52286,15 @@ fn aiur_fn_591( }) } -const INPUT_SIZE_592: usize = 2; -const IN_592: usize = 2; -const OUT_592: usize = 1; -fn aiur_fn_592( - inp: [G; IN_592], +const INPUT_SIZE_618: usize = 2; +const IN_618: usize = 2; +const OUT_618: usize = 1; +fn aiur_fn_618( + inp: [G; IN_618], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_592], ExecError> { +) -> Result<[G; OUT_618], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50321,8 +52305,8 @@ fn aiur_fn_592( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_592] = [__v_5]; - if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_5]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -50337,24 +52321,24 @@ fn aiur_fn_592( match __v_9.as_canonical_u64() { 0u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_592] = [__v_10]; - if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_10]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_592] = [__v_10]; - if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_10]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_592] = [__v_9]; - if let Some(result) = record.function_queries[592].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_618] = [__v_9]; + if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50366,15 +52350,15 @@ fn aiur_fn_592( }) } -const INPUT_SIZE_593: usize = 13; -const IN_593: usize = 13; -const OUT_593: usize = 1; -fn aiur_fn_593( - inp: [G; IN_593], +const INPUT_SIZE_619: usize = 13; +const IN_619: usize = 13; +const OUT_619: usize = 1; +fn aiur_fn_619( + inp: [G; IN_619], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_593], ExecError> { +) -> Result<[G; OUT_619], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50391,13 +52375,13 @@ fn aiur_fn_593( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_13.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_593] = [__v_14]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_14]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50405,25 +52389,25 @@ fn aiur_fn_593( 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_567] = { let __args: [G; IN_567] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(0); let __v_20: G = G::from_u64(0); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; match __v_22.as_canonical_u64() { 0u64 => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_593] = [__v_23]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_23]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { match __v_5.as_canonical_u64() { 1u64 => { let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -50441,22 +52425,22 @@ fn aiur_fn_593( match __v_25.as_canonical_u64() { 6u64 => { let __v_37: G = G::from_bool((__v_32 == G::ZERO)); - let __ret: [G; OUT_593] = [__v_37]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_37]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_37: G = G::from_u64(0); - let __ret: [G; OUT_593] = [__v_37]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_37]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_593] = [__v_23]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_23]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50467,23 +52451,23 @@ fn aiur_fn_593( }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_593] = [__v_13]; - if let Some(result) = record.function_queries[593].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_619] = [__v_13]; + if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_594: usize = 2; -const IN_594: usize = 2; -const OUT_594: usize = 1; -fn aiur_fn_594( - inp: [G; IN_594], +const INPUT_SIZE_620: usize = 2; +const IN_620: usize = 2; +const OUT_620: usize = 1; +fn aiur_fn_620( + inp: [G; IN_620], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_594], ExecError> { +) -> Result<[G; OUT_620], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50492,12 +52476,12 @@ fn aiur_fn_594( match __v_2.as_canonical_u64() { 1u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_594] = [__v_3]; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_3]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -50551,16 +52535,16 @@ fn aiur_fn_594( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_594] = [__v_52]; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_52]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_594] = [__v_51]; - if let Some(result) = record.function_queries[594].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_620] = [__v_51]; + if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50571,18 +52555,18 @@ fn aiur_fn_594( }) } -const INPUT_SIZE_595: usize = 1; -const IN_595: usize = 1; -const OUT_595: usize = 1; -fn aiur_fn_595( - inp: [G; IN_595], +const INPUT_SIZE_621: usize = 1; +const IN_621: usize = 1; +const OUT_621: usize = 1; +fn aiur_fn_621( + inp: [G; IN_621], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_595], ExecError> { +) -> Result<[G; OUT_621], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -50636,14 +52620,14 @@ fn aiur_fn_595( match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_595] = [__v_49]; - if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_621] = [__v_49]; + if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_595] = [__v_49]; - if let Some(result) = record.function_queries[595].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_621] = [__v_49]; + if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50652,15 +52636,15 @@ fn aiur_fn_595( }) } -const INPUT_SIZE_596: usize = 2; -const IN_596: usize = 2; -const OUT_596: usize = 1; -fn aiur_fn_596( - inp: [G; IN_596], +const INPUT_SIZE_622: usize = 2; +const IN_622: usize = 2; +const OUT_622: usize = 1; +fn aiur_fn_622( + inp: [G; IN_622], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_596], ExecError> { +) -> Result<[G; OUT_622], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50717,14 +52701,14 @@ fn aiur_fn_596( match __v_1.as_canonical_u64() { 1u64 => { let __v_49: G = G::from_u64(1); - let __ret: [G; OUT_596] = [__v_49]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_49]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_49: G = G::from_u64(0); - let __ret: [G; OUT_596] = [__v_49]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_49]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50734,17 +52718,17 @@ fn aiur_fn_596( 1u64 => { let __v_49: G = G::from_u64(1); let __v_50: G = (__v_1 + __v_49); - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_596] = [__v_51]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_51]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_622(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_596] = [__v_49]; - if let Some(result) = record.function_queries[596].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_622] = [__v_49]; + if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50756,15 +52740,15 @@ fn aiur_fn_596( }) } -const INPUT_SIZE_597: usize = 5; -const IN_597: usize = 5; -const OUT_597: usize = 1; -fn aiur_fn_597( - inp: [G; IN_597], +const INPUT_SIZE_623: usize = 5; +const IN_623: usize = 5; +const OUT_623: usize = 1; +fn aiur_fn_623( + inp: [G; IN_623], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_597], ExecError> { +) -> Result<[G; OUT_623], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50774,7 +52758,7 @@ fn aiur_fn_597( let __v_5: G = (__v_3 + __v_4); let __v_6: G = (__v_2 + __v_5); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_9: G = __loaded[0]; @@ -50793,8 +52777,8 @@ fn aiur_fn_597( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_597] = [__v_16]; - if let Some(result) = record.function_queries[597].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_623] = [__v_16]; + if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50809,15 +52793,15 @@ fn aiur_fn_597( }) } -const INPUT_SIZE_598: usize = 12; -const IN_598: usize = 12; -const OUT_598: usize = 1; -fn aiur_fn_598( - inp: [G; IN_598], +const INPUT_SIZE_624: usize = 12; +const IN_624: usize = 12; +const OUT_624: usize = 1; +fn aiur_fn_624( + inp: [G; IN_624], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_598], ExecError> { +) -> Result<[G; OUT_624], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50836,7 +52820,7 @@ fn aiur_fn_598( let __v_12: G = (__v_3 + __v_5); let __v_13: G = (__v_12 + __v_6); let __v_14: G = (__v_13 + __v_4); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_16: G = __loaded[0]; @@ -50855,16 +52839,16 @@ fn aiur_fn_598( let __v_25: G = __loaded[3]; match __v_22.as_canonical_u64() { 2u64 => { - let __ret: [G; OUT_598] = [__v_24]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_24]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_26: G = G::from_u64(1); let __v_27: G = G::from_u64(1); let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_598] = [__v_28]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_28]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50873,8 +52857,8 @@ fn aiur_fn_598( let __v_20: G = G::from_u64(1); let __v_21: G = G::from_u64(1); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_598] = [__v_22]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_22]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -50883,23 +52867,23 @@ fn aiur_fn_598( 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_598] = [__v_14]; - if let Some(result) = record.function_queries[598].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_624] = [__v_14]; + if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_599: usize = 6; -const IN_599: usize = 6; -const OUT_599: usize = 1; -fn aiur_fn_599( - inp: [G; IN_599], +const INPUT_SIZE_625: usize = 6; +const IN_625: usize = 6; +const OUT_625: usize = 1; +fn aiur_fn_625( + inp: [G; IN_625], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_599], ExecError> { +) -> Result<[G; OUT_625], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50910,7 +52894,7 @@ fn aiur_fn_599( let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -50922,14 +52906,14 @@ fn aiur_fn_599( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_16, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __ret: [G; OUT_599] = [__v_19]; - if let Some(result) = record.function_queries[599].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_625] = [__v_19]; + if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50939,15 +52923,15 @@ fn aiur_fn_599( }) } -const INPUT_SIZE_600: usize = 2; -const IN_600: usize = 2; -const OUT_600: usize = 1; -fn aiur_fn_600( - inp: [G; IN_600], +const INPUT_SIZE_626: usize = 2; +const IN_626: usize = 2; +const OUT_626: usize = 1; +fn aiur_fn_626( + inp: [G; IN_626], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_600], ExecError> { +) -> Result<[G; OUT_626], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -50960,13 +52944,13 @@ fn aiur_fn_600( 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_600] = [__v_7]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_7]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_325(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_347(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); if (__v_6 != __v_7) { @@ -50974,13 +52958,13 @@ fn aiur_fn_600( } let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_341(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_363(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_600(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_8, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_600] = [__v_12]; - if let Some(result) = record.function_queries[600].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_626] = [__v_12]; + if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -50990,15 +52974,15 @@ fn aiur_fn_600( }) } -const INPUT_SIZE_601: usize = 3; -const IN_601: usize = 3; -const OUT_601: usize = 1; -fn aiur_fn_601( - inp: [G; IN_601], +const INPUT_SIZE_627: usize = 3; +const IN_627: usize = 3; +const OUT_627: usize = 1; +fn aiur_fn_627( + inp: [G; IN_627], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_601], ExecError> { +) -> Result<[G; OUT_627], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51009,8 +52993,8 @@ fn aiur_fn_601( 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_601] = [__v_6]; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_6]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51021,30 +53005,30 @@ fn aiur_fn_601( 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_601] = { let __args: [G; IN_601] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_601] = [__v_12]; - if let Some(result) = record.function_queries[601].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_627] = [__v_12]; + if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_602: usize = 2; -const IN_602: usize = 2; -const OUT_602: usize = 1; -fn aiur_fn_602( - inp: [G; IN_602], +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_602], ExecError> { +) -> Result<[G; OUT_628], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -51098,14 +53082,14 @@ fn aiur_fn_602( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_602] = [__v_51]; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_51]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; @@ -51123,7 +53107,7 @@ fn aiur_fn_602( match __v_51.as_canonical_u64() { 5u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = G::from_u64(0); let __v_66: G = G::from_u64(0); @@ -51134,16 +53118,16 @@ fn aiur_fn_602( let __v_71: G = G::from_u64(1); let __v_72: G = { let __values: [G; 6] = [__v_70, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_73: G = { let __values: [G; 6] = [__v_65, __v_0, __v_66, __v_69, __v_64, __v_72]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_602] = [__v_73]; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_73]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(1); let __v_64: G = G::from_u64(1); let __v_65: G = { let __values: [G; 6] = [__v_63, __v_64, __v_64, __v_64, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_602] = [__v_65]; - if let Some(result) = record.function_queries[602].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_628] = [__v_65]; + if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51154,15 +53138,15 @@ fn aiur_fn_602( }) } -const INPUT_SIZE_603: usize = 5; -const IN_603: usize = 5; -const OUT_603: usize = 1; -fn aiur_fn_603( - inp: [G; IN_603], +const INPUT_SIZE_629: usize = 5; +const IN_629: usize = 5; +const OUT_629: usize = 1; +fn aiur_fn_629( + inp: [G; IN_629], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_603], ExecError> { +) -> Result<[G; OUT_629], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51222,16 +53206,16 @@ fn aiur_fn_603( let __v_52: G = G::from_u64(1); let __v_53: G = G::from_u64(1); let __v_54: G = { let __values: [G; 6] = [__v_52, __v_53, __v_53, __v_53, __v_53, __v_53]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_603] = [__v_54]; - if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_54]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; @@ -51258,7 +53242,7 @@ fn aiur_fn_603( }; let __v_66: G = __mc_out___mc_0[0]; let __v_67: G = G::from_u64(0); - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = G::from_u64(0); let __v_70: G = G::from_u64(0); @@ -51267,20 +53251,20 @@ fn aiur_fn_603( let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_74: G = G::from_u64(1); let __v_75: G = (__v_4 + __v_74); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; let __v_77: G = { let __values: [G; 6] = [__v_69, __v_52, __v_70, __v_73, __v_68, __v_76]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_603] = [__v_77]; - if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_77]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_4 + __v_52); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_603] = [__v_54]; - if let Some(result) = record.function_queries[603].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_629] = [__v_54]; + if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51292,15 +53276,15 @@ fn aiur_fn_603( }) } -const INPUT_SIZE_604: usize = 3; -const IN_604: usize = 3; -const OUT_604: usize = 1; -fn aiur_fn_604( - inp: [G; IN_604], +const INPUT_SIZE_630: usize = 3; +const IN_630: usize = 3; +const OUT_630: usize = 1; +fn aiur_fn_630( + inp: [G; IN_630], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_604], ExecError> { +) -> Result<[G; OUT_630], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51315,8 +53299,8 @@ fn aiur_fn_604( match __v_3.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_604] = [__v_9]; - if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_9]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -51326,38 +53310,38 @@ fn aiur_fn_604( let __v_9: G = __r_arr[0]; match __v_9.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; match __v_10.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(1); - let __ret: [G; OUT_604] = [__v_11]; - if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_11]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_604] = [__v_11]; - if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_11]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_604] = [__v_10]; - if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_10]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_604] = [__v_9]; - if let Some(result) = record.function_queries[604].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_630] = [__v_9]; + if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51369,15 +53353,15 @@ fn aiur_fn_604( }) } -const INPUT_SIZE_605: usize = 2; -const IN_605: usize = 2; -const OUT_605: usize = 1; -fn aiur_fn_605( - inp: [G; IN_605], +const INPUT_SIZE_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_605], ExecError> { +) -> Result<[G; OUT_631], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51385,8 +53369,8 @@ fn aiur_fn_605( match __v_2.as_canonical_u64() { 0u64 => { let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_605] = [__v_3]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_3]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -51408,22 +53392,22 @@ fn aiur_fn_605( match __v_11.as_canonical_u64() { 0u64 => { let __v_12: G = G::from_u64(1); - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_11]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51436,16 +53420,16 @@ fn aiur_fn_605( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_605] = [__v_11]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_11]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51462,24 +53446,24 @@ fn aiur_fn_605( let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_11]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51492,28 +53476,28 @@ fn aiur_fn_605( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 3u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_11]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51526,28 +53510,28 @@ fn aiur_fn_605( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 4u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_11]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51560,28 +53544,28 @@ fn aiur_fn_605( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_11]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51594,40 +53578,40 @@ fn aiur_fn_605( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_605] = [__v_13]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_13]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_13]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_13]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_11]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51640,16 +53624,16 @@ fn aiur_fn_605( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[318].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_318(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_340(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_605] = [__v_11]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_11]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51669,32 +53653,32 @@ fn aiur_fn_605( let __v_12: G = (__v_5 - __v_9); match __v_12.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_605] = [__v_13]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_13]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_13]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_13]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_12]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_12]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_605] = [__v_11]; - if let Some(result) = record.function_queries[605].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_631] = [__v_11]; + if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51708,15 +53692,15 @@ fn aiur_fn_605( }) } -const INPUT_SIZE_606: usize = 2; -const IN_606: usize = 2; -const OUT_606: usize = 1; -fn aiur_fn_606( - inp: [G; IN_606], +const INPUT_SIZE_632: usize = 2; +const IN_632: usize = 2; +const OUT_632: usize = 1; +fn aiur_fn_632( + inp: [G; IN_632], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_606], ExecError> { +) -> Result<[G; OUT_632], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51733,14 +53717,14 @@ fn aiur_fn_606( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_606] = [__v_8]; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_8]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_606] = [__v_8]; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_8]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51753,25 +53737,25 @@ fn aiur_fn_606( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_606] = [__v_8]; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_8]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_305(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_327(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_606(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_606] = [__v_9]; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_9]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_606] = [__v_9]; - if let Some(result) = record.function_queries[606].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_632] = [__v_9]; + if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51788,15 +53772,15 @@ fn aiur_fn_606( }) } -const INPUT_SIZE_607: usize = 2; -const IN_607: usize = 2; -const OUT_607: usize = 1; -fn aiur_fn_607( - inp: [G; IN_607], +const INPUT_SIZE_633: usize = 2; +const IN_633: usize = 2; +const OUT_633: usize = 1; +fn aiur_fn_633( + inp: [G; IN_633], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_607], ExecError> { +) -> Result<[G; OUT_633], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51813,14 +53797,14 @@ fn aiur_fn_607( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(1); - let __ret: [G; OUT_607] = [__v_8]; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_8]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_607] = [__v_8]; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_8]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51833,25 +53817,25 @@ fn aiur_fn_607( match __v_5.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_607] = [__v_8]; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_8]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; match __v_8.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_607] = [__v_9]; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_9]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_607] = [__v_9]; - if let Some(result) = record.function_queries[607].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_633] = [__v_9]; + if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51868,15 +53852,15 @@ fn aiur_fn_607( }) } -const INPUT_SIZE_608: usize = 13; -const IN_608: usize = 13; -const OUT_608: usize = 1; -fn aiur_fn_608( - inp: [G; IN_608], +const INPUT_SIZE_634: usize = 13; +const IN_634: usize = 13; +const OUT_634: usize = 1; +fn aiur_fn_634( + inp: [G; IN_634], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_608], ExecError> { +) -> Result<[G; OUT_634], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -51893,37 +53877,37 @@ fn aiur_fn_608( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_608] = [__v_13]; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_634] = [__v_13]; + if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_608] = [__v_15]; - if let Some(result) = record.function_queries[608].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_634] = [__v_15]; + if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_609: usize = 2; -const IN_609: usize = 2; -const OUT_609: usize = 1; -fn aiur_fn_609( - inp: [G; IN_609], +const INPUT_SIZE_635: usize = 2; +const IN_635: usize = 2; +const OUT_635: usize = 1; +fn aiur_fn_635( + inp: [G; IN_635], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_609], ExecError> { +) -> Result<[G; OUT_635], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -51977,15 +53961,15 @@ fn aiur_fn_609( match __v_2.as_canonical_u64() { 8u64 => { let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __ret: [G; OUT_609] = [__v_51]; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_51]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_609] = [__v_1]; - if let Some(result) = record.function_queries[609].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_635] = [__v_1]; + if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -51994,15 +53978,15 @@ fn aiur_fn_609( }) } -const INPUT_SIZE_610: usize = 5; -const IN_610: usize = 5; -const OUT_610: usize = 1; -fn aiur_fn_610( - inp: [G; IN_610], +const INPUT_SIZE_636: usize = 5; +const IN_636: usize = 5; +const OUT_636: usize = 1; +fn aiur_fn_636( + inp: [G; IN_636], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_610], ExecError> { +) -> Result<[G; OUT_636], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52059,16 +54043,16 @@ fn aiur_fn_610( let __v_51: G = __loaded[46]; match __v_5.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_610] = [__v_4]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_4]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_6.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_53.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_54: G = __loaded[0]; @@ -52085,9 +54069,9 @@ fn aiur_fn_610( let __v_65: G = __loaded[11]; match __v_54.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_67.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_68: G = __loaded[0]; @@ -52104,20 +54088,20 @@ fn aiur_fn_610( let __v_79: G = __loaded[11]; match __v_68.as_canonical_u64() { 5u64 => { - let __ret: [G; OUT_610] = [__v_75]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_75]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_610] = [__v_4]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_4]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_610] = [__v_4]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_4]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52125,10 +54109,10 @@ fn aiur_fn_610( _ => { let __v_52: G = G::from_u64(1); let __v_53: G = (__v_3 + __v_52); - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_610] = [__v_54]; - if let Some(result) = record.function_queries[610].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_636] = [__v_54]; + if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52140,20 +54124,20 @@ fn aiur_fn_610( }) } -const INPUT_SIZE_611: usize = 3; -const IN_611: usize = 3; -const OUT_611: usize = 1; -fn aiur_fn_611( - inp: [G; IN_611], +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_611], ExecError> { +) -> Result<[G; OUT_637], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -52207,7 +54191,7 @@ fn aiur_fn_611( match __v_3.as_canonical_u64() { 8u64 => { let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_610(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; break '__mc_0 [__v_52]; }, @@ -52219,7 +54203,7 @@ fn aiur_fn_611( } }; let __v_51: G = __mc_out___mc_0[0]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; let __v_54: G = __r_arr[2]; @@ -52273,12 +54257,12 @@ fn aiur_fn_611( match __v_52.as_canonical_u64() { 8u64 => { let __v_100: G = G::from_u64(0); - let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_603(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; break '__mc_1 [__v_101]; }, _ => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_100.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_101: G = __loaded[0]; @@ -52296,7 +54280,7 @@ fn aiur_fn_611( match __v_101.as_canonical_u64() { 5u64 => { let __v_113: G = G::from_u64(0); - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; let __v_115: G = G::from_u64(0); let __v_116: G = G::from_u64(0); @@ -52322,40 +54306,40 @@ fn aiur_fn_611( } }; let __v_100: G = __mc_out___mc_1[0]; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_101: G = __r_arr[0]; match __v_101.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_611] = [__v_100]; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_637] = [__v_100]; + if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; let __v_102: G = __r_arr[0]; - let __ret: [G; OUT_611] = [__v_102]; - if let Some(result) = record.function_queries[611].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_637] = [__v_102]; + if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_612: usize = 4; -const IN_612: usize = 4; -const OUT_612: usize = 1; -fn aiur_fn_612( - inp: [G; IN_612], +const INPUT_SIZE_638: usize = 4; +const IN_638: usize = 4; +const OUT_638: usize = 1; +fn aiur_fn_638( + inp: [G; IN_638], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_612], ExecError> { +) -> Result<[G; OUT_638], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -52409,15 +54393,15 @@ fn aiur_fn_612( match __v_4.as_canonical_u64() { 8u64 => { let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __ret: [G; OUT_612] = [__v_53]; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_638] = [__v_53]; + if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_612] = [__v_3]; - if let Some(result) = record.function_queries[612].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_638] = [__v_3]; + if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52426,15 +54410,15 @@ fn aiur_fn_612( }) } -const INPUT_SIZE_613: usize = 7; -const IN_613: usize = 7; -const OUT_613: usize = 1; -fn aiur_fn_613( - inp: [G; IN_613], +const INPUT_SIZE_639: usize = 7; +const IN_639: usize = 7; +const OUT_639: usize = 1; +fn aiur_fn_639( + inp: [G; IN_639], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_613], ExecError> { +) -> Result<[G; OUT_639], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52493,16 +54477,16 @@ fn aiur_fn_613( let __v_53: G = __loaded[46]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_613] = [__v_5]; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_5]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_8.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_55.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_56: G = __loaded[0]; @@ -52519,9 +54503,9 @@ fn aiur_fn_613( let __v_67: G = __loaded[11]; let __mc_out___mc_0: [G; 5] = '__mc_0: { match __v_56.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_70: G = __loaded[0]; @@ -52580,39 +54564,39 @@ fn aiur_fn_613( 0u64 => { let __v_73: G = G::from_u64(1); let __v_74: G = (__v_6 + __v_73); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __ret: [G; OUT_613] = [__v_75]; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_75]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; - let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_598(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; - let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_604(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; match __v_75.as_canonical_u64() { 1u64 => { let __v_76: G = G::from_u64(1); let __v_77: G = (__v_6 + __v_76); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __ret: [G; OUT_613] = [__v_78]; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_78]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_76: G = G::from_u64(1); - let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_6 + __v_78); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_613] = [__v_80]; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_80]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52622,10 +54606,10 @@ fn aiur_fn_613( _ => { let __v_54: G = G::from_u64(1); let __v_55: G = (__v_6 + __v_54); - let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[613].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_613(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __ret: [G; OUT_613] = [__v_56]; - if let Some(result) = record.function_queries[613].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_639] = [__v_56]; + if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52637,15 +54621,15 @@ fn aiur_fn_613( }) } -const INPUT_SIZE_614: usize = 3; -const IN_614: usize = 3; -const OUT_614: usize = 2; -fn aiur_fn_614( - inp: [G; IN_614], +const INPUT_SIZE_640: usize = 3; +const IN_640: usize = 3; +const OUT_640: usize = 2; +fn aiur_fn_640( + inp: [G; IN_640], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_614], ExecError> { +) -> Result<[G; OUT_640], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52661,8 +54645,8 @@ fn aiur_fn_614( 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_614] = [__v_9, __v_10]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_640] = [__v_9, __v_10]; + if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -52671,18 +54655,18 @@ fn aiur_fn_614( match __v_9.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(1); - let __ret: [G; OUT_614] = [__v_10, __v_2]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_640] = [__v_10, __v_2]; + if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_10: G = G::from_u64(1); let __v_11: G = (__v_2 + __v_10); - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; - let __ret: [G; OUT_614] = [__v_12, __v_13]; - if let Some(result) = record.function_queries[614].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_640] = [__v_12, __v_13]; + if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52694,15 +54678,15 @@ fn aiur_fn_614( }) } -const INPUT_SIZE_615: usize = 5; -const IN_615: usize = 5; -const OUT_615: usize = 2; -fn aiur_fn_615( - inp: [G; IN_615], +const INPUT_SIZE_641: usize = 5; +const IN_641: usize = 5; +const OUT_641: usize = 2; +fn aiur_fn_641( + inp: [G; IN_641], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_615], ExecError> { +) -> Result<[G; OUT_641], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52720,8 +54704,8 @@ fn aiur_fn_615( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_615] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -52742,7 +54726,7 @@ fn aiur_fn_615( let __v_13: G = __mc_out___mc_0[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_2.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; break '__mc_1 [__v_14]; }, @@ -52758,18 +54742,18 @@ fn aiur_fn_615( match __v_16.as_canonical_u64() { 1u64 => { let __v_17: G = G::from_u64(1); - let __ret: [G; OUT_615] = [__v_17, __v_4]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_17, __v_4]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(1); let __v_18: G = (__v_4 + __v_17); - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_615] = [__v_19, __v_20]; - if let Some(result) = record.function_queries[615].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[615].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_641] = [__v_19, __v_20]; + if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52781,15 +54765,15 @@ fn aiur_fn_615( }) } -const INPUT_SIZE_616: usize = 2; -const IN_616: usize = 2; -const OUT_616: usize = 4; -fn aiur_fn_616( - inp: [G; IN_616], +const INPUT_SIZE_642: usize = 2; +const IN_642: usize = 2; +const OUT_642: usize = 4; +fn aiur_fn_642( + inp: [G; IN_642], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_616], ExecError> { +) -> Result<[G; OUT_642], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52842,27 +54826,27 @@ fn aiur_fn_616( let __v_45: G = G::from_u64(1); let __v_46: G = G::from_u64(1); let __v_47: G = { let __values: [G; 3] = [__v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_616] = [__v_40, __v_41, __v_44, __v_47]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_642] = [__v_40, __v_41, __v_44, __v_47]; + if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_616] = [__v_3, __v_4, __v_5, __v_6]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_642] = [__v_3, __v_4, __v_5, __v_6]; + if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 - __v_8); - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __ret: [G; OUT_616] = [__v_10, __v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[616].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_642] = [__v_10, __v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52874,15 +54858,15 @@ fn aiur_fn_616( }) } -const INPUT_SIZE_617: usize = 4; -const IN_617: usize = 4; -const OUT_617: usize = 1; -fn aiur_fn_617( - inp: [G; IN_617], +const INPUT_SIZE_643: usize = 4; +const IN_643: usize = 4; +const OUT_643: usize = 1; +fn aiur_fn_643( + inp: [G; IN_643], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_617], ExecError> { +) -> Result<[G; OUT_643], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52896,20 +54880,20 @@ fn aiur_fn_617( 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_617] = [__v_9]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_643] = [__v_9]; + if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_617] = [__v_6]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_643] = [__v_6]; + if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52919,8 +54903,8 @@ fn aiur_fn_617( 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_617] = [__v_11]; - if let Some(result) = record.function_queries[617].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_643] = [__v_11]; + if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -52929,15 +54913,15 @@ fn aiur_fn_617( }) } -const INPUT_SIZE_618: usize = 6; -const IN_618: usize = 6; -const OUT_618: usize = 1; -fn aiur_fn_618( - inp: [G; IN_618], +const INPUT_SIZE_644: usize = 6; +const IN_644: usize = 6; +const OUT_644: usize = 1; +fn aiur_fn_644( + inp: [G; IN_644], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_618], ExecError> { +) -> Result<[G; OUT_644], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -52947,8 +54931,8 @@ fn aiur_fn_618( let __v_5: G = inp[5]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_618] = [__v_0]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_644] = [__v_0]; + if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52959,19 +54943,19 @@ fn aiur_fn_618( let __v_9: G = __loaded[3]; match __v_6.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_617(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_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_618] = { let __args: [G; IN_618] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_618] = [__v_17]; - if let Some(result) = record.function_queries[618].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_644] = [__v_17]; + if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -52983,15 +54967,15 @@ fn aiur_fn_618( }) } -const INPUT_SIZE_619: usize = 2; -const IN_619: usize = 2; -const OUT_619: usize = 1; -fn aiur_fn_619( - inp: [G; IN_619], +const INPUT_SIZE_645: usize = 2; +const IN_645: usize = 2; +const OUT_645: usize = 1; +fn aiur_fn_645( + inp: [G; IN_645], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_619], ExecError> { +) -> Result<[G; OUT_645], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53000,8 +54984,8 @@ fn aiur_fn_619( 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_619] = [__v_4]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_4]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53015,18 +54999,18 @@ fn aiur_fn_619( 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_619] = { let __args: [G; IN_619] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_619] = [__v_10]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_10]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -53038,19 +55022,19 @@ fn aiur_fn_619( let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); let __v_16: G = (__v_1 - __v_15); - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = { let __values: [G; 3] = [__v_14, __v_11, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_619] = [__v_18]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_18]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_619] = [__v_16]; - if let Some(result) = record.function_queries[619].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_645] = [__v_16]; + if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53061,15 +55045,15 @@ fn aiur_fn_619( }) } -const INPUT_SIZE_620: usize = 4; -const IN_620: usize = 4; -const OUT_620: usize = 1; -fn aiur_fn_620( - inp: [G; IN_620], +const INPUT_SIZE_646: usize = 4; +const IN_646: usize = 4; +const OUT_646: usize = 1; +fn aiur_fn_646( + inp: [G; IN_646], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_620], ExecError> { +) -> Result<[G; OUT_646], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53078,8 +55062,8 @@ fn aiur_fn_620( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_620] = [__v_0]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_646] = [__v_0]; + if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53095,25 +55079,25 @@ fn aiur_fn_620( 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_620] = { let __args: [G; IN_620] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __ret: [G; OUT_620] = [__v_17]; - if let Some(result) = record.function_queries[620].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_646] = [__v_17]; + if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_621: usize = 3; -const IN_621: usize = 3; -const OUT_621: usize = 1; -fn aiur_fn_621( - inp: [G; IN_621], +const INPUT_SIZE_647: usize = 3; +const IN_647: usize = 3; +const OUT_647: usize = 1; +fn aiur_fn_647( + inp: [G; IN_647], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_621], ExecError> { +) -> Result<[G; OUT_647], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53124,21 +55108,21 @@ fn aiur_fn_621( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_621] = [__v_0]; - if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_0]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_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_621] = { let __args: [G; IN_621] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_621] = [__v_11]; - if let Some(result) = record.function_queries[621].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_647] = [__v_11]; + if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53148,15 +55132,15 @@ fn aiur_fn_621( }) } -const INPUT_SIZE_622: usize = 5; -const IN_622: usize = 5; -const OUT_622: usize = 1; -fn aiur_fn_622( - inp: [G; IN_622], +const INPUT_SIZE_648: usize = 5; +const IN_648: usize = 5; +const OUT_648: usize = 1; +fn aiur_fn_648( + inp: [G; IN_648], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_622], ExecError> { +) -> Result<[G; OUT_648], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53166,32 +55150,32 @@ fn aiur_fn_622( match __v_3.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_622] = [__v_6]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_648] = [__v_6]; + if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __ret: [G; OUT_622] = [__v_5]; - if let Some(result) = record.function_queries[622].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_648] = [__v_5]; + if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_623: usize = 3; -const IN_623: usize = 3; -const OUT_623: usize = 1; -fn aiur_fn_623( - inp: [G; IN_623], +const INPUT_SIZE_649: usize = 3; +const IN_649: usize = 3; +const OUT_649: usize = 1; +fn aiur_fn_649( + inp: [G; IN_649], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_623], ExecError> { +) -> Result<[G; OUT_649], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53199,8 +55183,8 @@ fn aiur_fn_623( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_623] = [__v_0]; - if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_649] = [__v_0]; + if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53215,25 +55199,25 @@ fn aiur_fn_623( 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_623] = { let __args: [G; IN_623] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_623] = [__v_15]; - if let Some(result) = record.function_queries[623].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_649] = [__v_15]; + if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_624: usize = 2; -const IN_624: usize = 2; -const OUT_624: usize = 1; -fn aiur_fn_624( - inp: [G; IN_624], +const INPUT_SIZE_650: usize = 2; +const IN_650: usize = 2; +const OUT_650: usize = 1; +fn aiur_fn_650( + inp: [G; IN_650], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_624], ExecError> { +) -> Result<[G; OUT_650], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53243,18 +55227,18 @@ fn aiur_fn_624( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_624] = [__v_0]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_650] = [__v_0]; + if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(5); - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_624] = [__v_8]; - if let Some(result) = record.function_queries[624].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_650] = [__v_8]; + if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53264,15 +55248,15 @@ fn aiur_fn_624( }) } -const INPUT_SIZE_625: usize = 2; -const IN_625: usize = 2; -const OUT_625: usize = 2; -fn aiur_fn_625( - inp: [G; IN_625], +const INPUT_SIZE_651: usize = 2; +const IN_651: usize = 2; +const OUT_651: usize = 2; +fn aiur_fn_651( + inp: [G; IN_651], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_625], ExecError> { +) -> Result<[G; OUT_651], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53281,8 +55265,8 @@ fn aiur_fn_625( 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_625] = [__v_4, __v_0]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_651] = [__v_4, __v_0]; + if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53295,20 +55279,20 @@ fn aiur_fn_625( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 - __v_6); - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 3] = [__v_10, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_625] = [__v_11, __v_9]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_651] = [__v_11, __v_9]; + if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(1); let __v_7: G = G::from_u64(1); let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -53319,21 +55303,21 @@ fn aiur_fn_625( 5u64 => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __v_18: G = G::from_u64(0); let __v_19: G = { let __values: [G; 3] = [__v_18, __v_11, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_625] = [__v_19, __v_17]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_651] = [__v_19, __v_17]; + if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = G::from_u64(1); let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_625] = [__v_16, __v_0]; - if let Some(result) = record.function_queries[625].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_651] = [__v_16, __v_0]; + if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -53344,15 +55328,15 @@ fn aiur_fn_625( }) } -const INPUT_SIZE_626: usize = 3; -const IN_626: usize = 3; -const OUT_626: usize = 1; -fn aiur_fn_626( - inp: [G; IN_626], +const INPUT_SIZE_652: usize = 3; +const IN_652: usize = 3; +const OUT_652: usize = 1; +fn aiur_fn_652( + inp: [G; IN_652], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_626], ExecError> { +) -> Result<[G; OUT_652], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53366,21 +55350,21 @@ fn aiur_fn_626( 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_626] = [__v_8]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_652] = [__v_8]; + if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_2 + __v_8); - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_626] = [__v_11]; - if let Some(result) = record.function_queries[626].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_652] = [__v_11]; + if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53390,15 +55374,15 @@ fn aiur_fn_626( }) } -const INPUT_SIZE_627: usize = 6; -const IN_627: usize = 6; -const OUT_627: usize = 1; -fn aiur_fn_627( - inp: [G; IN_627], +const INPUT_SIZE_653: usize = 6; +const IN_653: usize = 6; +const OUT_653: usize = 1; +fn aiur_fn_653( + inp: [G; IN_653], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_627], ExecError> { +) -> Result<[G; OUT_653], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53408,33 +55392,33 @@ fn aiur_fn_627( let __v_5: G = inp[5]; match __v_4.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_6]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_653] = [__v_6]; + if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_627] = [__v_7]; - if let Some(result) = record.function_queries[627].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_653] = [__v_7]; + if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_628: usize = 3; -const IN_628: usize = 3; -const OUT_628: usize = 1; -fn aiur_fn_628( - inp: [G; IN_628], +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_628], ExecError> { +) -> Result<[G; OUT_654], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53442,8 +55426,8 @@ fn aiur_fn_628( let __v_3: G = (__v_1 - __v_2); match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_628] = [__v_0]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_654] = [__v_0]; + if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53456,25 +55440,25 @@ fn aiur_fn_628( 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_628] = { let __args: [G; IN_628] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_628] = [__v_13]; - if let Some(result) = record.function_queries[628].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_654] = [__v_13]; + if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_629: usize = 9; -const IN_629: usize = 9; -const OUT_629: usize = 1; -fn aiur_fn_629( - inp: [G; IN_629], +const INPUT_SIZE_655: usize = 9; +const IN_655: usize = 9; +const OUT_655: usize = 1; +fn aiur_fn_655( + inp: [G; IN_655], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_629], ExecError> { +) -> Result<[G; OUT_655], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53485,12 +55469,12 @@ fn aiur_fn_629( let __v_6: G = inp[6]; let __v_7: G = inp[7]; let __v_8: G = inp[8]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(2); let __v_14: G = G::from_u64(0); @@ -53498,12 +55482,12 @@ fn aiur_fn_629( let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { 0u64 => { let __v_16: G = G::from_u64(0); - let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; break '__mc_0 [__v_17]; }, _ => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; break '__mc_0 [__v_16]; }, @@ -53511,7 +55495,7 @@ fn aiur_fn_629( }; let __v_16: G = __mc_out___mc_0[0]; let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(0); @@ -53519,45 +55503,45 @@ fn aiur_fn_629( let __v_22: G = G::from_u64(5); let __v_23: G = G::from_u64(0); let __v_24: G = { let __values: [G; 4] = [__v_22, __v_18, __v_21, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_24, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_629] = [__v_25]; - if let Some(result) = record.function_queries[629].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_655] = [__v_25]; + if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_630: usize = 3; -const IN_630: usize = 3; -const OUT_630: usize = 1; -fn aiur_fn_630( - inp: [G; IN_630], +const INPUT_SIZE_656: usize = 3; +const IN_656: usize = 3; +const OUT_656: usize = 1; +fn aiur_fn_656( + inp: [G; IN_656], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_630], ExecError> { +) -> Result<[G; OUT_656], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = G::from_u64(0); - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_630] = [__v_4]; - if let Some(result) = record.function_queries[630].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_656] = [__v_4]; + if let Some(result) = record.function_queries[656].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_631: usize = 4; -const IN_631: usize = 4; -const OUT_631: usize = 1; -fn aiur_fn_631( - inp: [G; IN_631], +const INPUT_SIZE_657: usize = 4; +const IN_657: usize = 4; +const OUT_657: usize = 1; +fn aiur_fn_657( + inp: [G; IN_657], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_631], ExecError> { +) -> Result<[G; OUT_657], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53566,8 +55550,8 @@ fn aiur_fn_631( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_631] = [__v_0]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_657] = [__v_0]; + if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53580,25 +55564,25 @@ fn aiur_fn_631( 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_631] = { let __args: [G; IN_631] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_631] = [__v_14]; - if let Some(result) = record.function_queries[631].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_657] = [__v_14]; + if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_632: usize = 2; -const IN_632: usize = 2; -const OUT_632: usize = 1; -fn aiur_fn_632( - inp: [G; IN_632], +const INPUT_SIZE_658: usize = 2; +const IN_658: usize = 2; +const OUT_658: usize = 1; +fn aiur_fn_658( + inp: [G; IN_658], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_632], ExecError> { +) -> Result<[G; OUT_658], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53608,18 +55592,18 @@ fn aiur_fn_632( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_632] = [__v_0]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_658] = [__v_0]; + if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(4); - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(0); let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_632] = [__v_8]; - if let Some(result) = record.function_queries[632].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_658] = [__v_8]; + if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53629,15 +55613,15 @@ fn aiur_fn_632( }) } -const INPUT_SIZE_633: usize = 9; -const IN_633: usize = 9; -const OUT_633: usize = 1; -fn aiur_fn_633( - inp: [G; IN_633], +const INPUT_SIZE_659: usize = 9; +const IN_659: usize = 9; +const OUT_659: usize = 1; +fn aiur_fn_659( + inp: [G; IN_659], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_633], ExecError> { +) -> Result<[G; OUT_659], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53649,12 +55633,12 @@ fn aiur_fn_633( 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_616] = { let __args: [G; IN_616] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; let __v_13: G = __r_arr[3]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -53671,32 +55655,32 @@ fn aiur_fn_633( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_633] = [__v_27]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_659] = [__v_27]; + if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __ret: [G; OUT_633] = [__v_27]; - if let Some(result) = record.function_queries[633].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_659] = [__v_27]; + if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_634: usize = 11; -const IN_634: usize = 11; -const OUT_634: usize = 1; -fn aiur_fn_634( - inp: [G; IN_634], +const INPUT_SIZE_660: usize = 11; +const IN_660: usize = 11; +const OUT_660: usize = 1; +fn aiur_fn_660( + inp: [G; IN_660], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_634], ExecError> { +) -> Result<[G; OUT_660], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53709,28 +55693,28 @@ fn aiur_fn_634( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = inp[10]; - let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_601(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_627(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_630(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_648(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; let __v_23: G = __r_arr[3]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_25: G = __loaded[0]; @@ -53747,16 +55731,16 @@ fn aiur_fn_634( let __v_36: G = __loaded[11]; match __v_25.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_27, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = G::from_u64(0); - let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_618(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_39, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_39, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = (__v_11 + __v_19); let __v_42: G = G::from_u64(0); - let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_626(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); @@ -53770,13 +55754,13 @@ fn aiur_fn_634( let __v_53: G = (__v_52 + __v_5); let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_21.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; break '__mc_0 [__v_54]; }, _ => { let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; break '__mc_0 [__v_55]; }, @@ -53784,7 +55768,7 @@ fn aiur_fn_634( }; let __v_54: G = __mc_out___mc_0[0]; let __v_55: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = G::from_u64(1); let __v_58: G = (__v_49 + __v_57); @@ -53796,7 +55780,7 @@ fn aiur_fn_634( let __v_64: G = G::from_u64(0); let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_66: G = G::from_u64(0); - let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_628(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = G::from_u64(3); let __v_69: G = G::from_u64(0); @@ -53808,16 +55792,16 @@ fn aiur_fn_634( let __v_75: G = G::from_u64(5); let __v_76: G = G::from_u64(0); let __v_77: G = { let __values: [G; 4] = [__v_75, __v_56, __v_74, __v_76]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_77, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_77, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_78, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_78, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_79, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_79, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_80, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_80, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __ret: [G; OUT_634] = [__v_81]; - if let Some(result) = record.function_queries[634].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_660] = [__v_81]; + if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -53827,15 +55811,15 @@ fn aiur_fn_634( }) } -const INPUT_SIZE_635: usize = 26; -const IN_635: usize = 26; -const OUT_635: usize = 0; -fn aiur_fn_635( - inp: [G; IN_635], +const INPUT_SIZE_661: usize = 26; +const IN_661: usize = 26; +const OUT_661: usize = 0; +fn aiur_fn_661( + inp: [G; IN_661], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_635], ExecError> { +) -> Result<[G; OUT_661], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -53870,7 +55854,7 @@ fn aiur_fn_635( let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() { 1u64 => { let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_28: G = __loaded[0]; @@ -53921,11 +55905,11 @@ fn aiur_fn_635( let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; - let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_594(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[620].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_620(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_620] = unsafe { *(result.output.as_ptr() as *const [G; OUT_620]) }; __ret } } else { aiur_fn_620(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; - let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_588(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_43, __v_18, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_45.as_canonical_u64() { 1u64 => { @@ -53945,17 +55929,17 @@ fn aiur_fn_635( }; let __v_46: G = __mc_out___mc_1[0]; let __v_47: G = G::from_u64(0); - let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_1, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(1); let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; @@ -53965,7 +55949,7 @@ fn aiur_fn_635( let __v_58: G = (__v_52 * __v_57); let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_58.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_634(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; break '__mc_2 [__v_59]; }, @@ -53979,26 +55963,26 @@ fn aiur_fn_635( }; let __v_59: G = __mc_out___mc_2[0]; let __v_60: G = G::from_u64(0); - let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_615(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; match __v_61.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_635] = []; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_614(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; match __v_64.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_636(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_635] = []; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54009,8 +55993,8 @@ fn aiur_fn_635( } }, _ => { - let __ret: [G; OUT_635] = []; - if let Some(result) = record.function_queries[635].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_661] = []; + if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54022,15 +56006,15 @@ fn aiur_fn_635( }) } -const INPUT_SIZE_636: usize = 18; -const IN_636: usize = 18; -const OUT_636: usize = 0; -fn aiur_fn_636( - inp: [G; IN_636], +const INPUT_SIZE_662: usize = 18; +const IN_662: usize = 18; +const OUT_662: usize = 0; +fn aiur_fn_662( + inp: [G; IN_662], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_636], ExecError> { +) -> Result<[G; OUT_662], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54050,45 +56034,45 @@ fn aiur_fn_636( let __v_15: G = inp[15]; let __v_16: G = inp[16]; let __v_17: G = inp[17]; - let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_616(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_0, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = G::from_u64(0); - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_2, __v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_2, __v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_21, __v_8, __v_0, __v_9, __v_10, __v_19, __v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = G::from_u64(1); let __v_28: G = G::from_u64(1); let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_12, __v_22, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_12, __v_22, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); if (__v_30 != __v_31) { return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) }); } let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_11, __v_26, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_636] = []; - if let Some(result) = record.function_queries[636].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_11, __v_26, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_662] = []; + if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_637: usize = 3; -const IN_637: usize = 3; -const OUT_637: usize = 1; -fn aiur_fn_637( - inp: [G; IN_637], +const INPUT_SIZE_663: usize = 3; +const IN_663: usize = 3; +const OUT_663: usize = 1; +fn aiur_fn_663( + inp: [G; IN_663], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_637], ExecError> { +) -> Result<[G; OUT_663], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54097,8 +56081,8 @@ fn aiur_fn_637( match __v_3.as_canonical_u64() { 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_637] = [__v_4]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_663] = [__v_4]; + if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54112,12 +56096,12 @@ fn aiur_fn_637( match __v_4.as_canonical_u64() { 1u64 => { let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_637] = [__v_10]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_663] = [__v_10]; + if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -54145,11 +56129,11 @@ fn aiur_fn_637( let __v_23: G = __mc_out___mc_0[0]; let __v_24: G = G::from_u64(1); let __v_25: G = (__v_2 + __v_24); - let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_637(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = (__v_23 + __v_26); - let __ret: [G; OUT_637] = [__v_27]; - if let Some(result) = record.function_queries[637].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_663] = [__v_27]; + if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54161,15 +56145,15 @@ fn aiur_fn_637( }) } -const INPUT_SIZE_638: usize = 15; -const IN_638: usize = 15; -const OUT_638: usize = 1; -fn aiur_fn_638( - inp: [G; IN_638], +const INPUT_SIZE_664: usize = 15; +const IN_664: usize = 15; +const OUT_664: usize = 1; +fn aiur_fn_664( + inp: [G; IN_664], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_638], ExecError> { +) -> Result<[G; OUT_664], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54192,12 +56176,12 @@ fn aiur_fn_638( 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_638] = [__v_18]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_664] = [__v_18]; + if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -54215,24 +56199,24 @@ fn aiur_fn_638( match __v_17.as_canonical_u64() { 6u64 => { let __v_29: G = (__v_1 + __v_14); - let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_641(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_19, __v_29, __v_4, __v_5, __v_6, __v_23, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_14 + __v_32); - let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_638(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = { let __values: [G; 3] = [__v_31, __v_30, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_638] = [__v_35]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_664] = [__v_35]; + if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_29: G = G::from_u64(1); let __v_30: G = G::from_u64(1); let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_638] = [__v_31]; - if let Some(result) = record.function_queries[638].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_664] = [__v_31]; + if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54241,15 +56225,15 @@ fn aiur_fn_638( }) } -const INPUT_SIZE_639: usize = 9; -const IN_639: usize = 9; -const OUT_639: usize = 0; -fn aiur_fn_639( - inp: [G; IN_639], +const INPUT_SIZE_665: usize = 9; +const IN_665: usize = 9; +const OUT_665: usize = 0; +fn aiur_fn_665( + inp: [G; IN_665], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_639], ExecError> { +) -> Result<[G; OUT_665], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54268,14 +56252,14 @@ fn aiur_fn_639( let __v_13: G = __loaded[4]; match __v_9.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_639] = []; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_665] = []; + if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_10.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -54316,8 +56300,8 @@ fn aiur_fn_639( let __v_31: G = __loaded[2]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_639] = []; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_665] = []; + if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -54328,7 +56312,7 @@ fn aiur_fn_639( let __v_36: G = G::from_u64(1); let __v_37: G = G::from_u64(1); let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -54338,7 +56322,7 @@ fn aiur_fn_639( 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_414] = { let __args: [G; IN_414] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_414(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_439(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = G::from_u64(1); if (__v_45 != __v_46) { @@ -54346,9 +56330,9 @@ fn aiur_fn_639( } let __v_47: G = G::from_u64(1); let __v_48: G = (__v_8 + __v_47); - let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_639(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_639] = []; - if let Some(result) = record.function_queries[639].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_665] = []; + if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54365,15 +56349,15 @@ fn aiur_fn_639( }) } -const INPUT_SIZE_640: usize = 12; -const IN_640: usize = 12; -const OUT_640: usize = 1; -fn aiur_fn_640( - inp: [G; IN_640], +const INPUT_SIZE_666: usize = 12; +const IN_666: usize = 12; +const OUT_666: usize = 1; +fn aiur_fn_666( + inp: [G; IN_666], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_640], ExecError> { +) -> Result<[G; OUT_666], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54393,13 +56377,13 @@ fn aiur_fn_640( let __v_14: G = __loaded[2]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_640] = [__v_0]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_0]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); @@ -54434,27 +56418,27 @@ fn aiur_fn_640( let __v_47: G = G::from_u64(0); let __v_48: G = G::from_u64(0); let __v_49: G = { let __values: [G; 32] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = G::from_u64(0); - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = (__v_6 + __v_7); let __v_54: G = (__v_53 + __v_8); let __v_55: G = (__v_54 + __v_9); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __v_57: G = (__v_9 - __v_13); let __v_58: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_59: G = __r_arr[0]; let __v_60: G = (__v_7 + __v_8); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = (__v_55 + __v_64); let __v_66: G = G::from_u64(2); @@ -54463,32 +56447,32 @@ fn aiur_fn_640( let __v_69: G = G::from_u64(1); let __v_70: G = (__v_65 - __v_69); let __v_71: G = G::from_u64(0); - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __v_73: G = G::from_u64(1); let __v_74: G = (__v_65 - __v_73); let __v_75: G = (__v_74 - __v_6); let __v_76: G = G::from_u64(0); - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); let __v_79: G = (__v_65 - __v_78); let __v_80: G = (__v_79 - __v_6); let __v_81: G = (__v_80 - __v_7); let __v_82: G = G::from_u64(0); - let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = G::from_u64(1); let __v_85: G = G::from_u64(1); let __v_86: G = { let __values: [G; 3] = [__v_84, __v_85, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_63, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_88: G = __r_arr[0]; let __v_89: G = __r_arr[1]; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_89, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_90: G = __r_arr[0]; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_83, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = G::from_u64(1); let __v_93: G = (__v_9 - __v_92); @@ -54498,22 +56482,22 @@ fn aiur_fn_640( let __v_97: G = G::from_u64(0); let __v_98: G = { let __values: [G; 4] = [__v_96, __v_95, __v_97, __v_97]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_99: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; let __v_100: G = __r_arr[0]; let __v_101: G = G::from_u64(3); let __v_102: G = G::from_u64(0); let __v_103: G = { let __values: [G; 4] = [__v_101, __v_91, __v_100, __v_102]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_632(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_103, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; let __v_104: G = __r_arr[0]; let __v_105: G = G::from_u64(3); let __v_106: G = G::from_u64(0); let __v_107: G = { let __values: [G; 4] = [__v_105, __v_0, __v_104, __v_106]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_108: G = G::from_u64(1); let __v_109: G = (__v_11 + __v_108); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_107, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_110: G = __r_arr[0]; - let __ret: [G; OUT_640] = [__v_110]; - if let Some(result) = record.function_queries[640].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_666] = [__v_110]; + if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54523,15 +56507,15 @@ fn aiur_fn_640( }) } -const INPUT_SIZE_641: usize = 13; -const IN_641: usize = 13; -const OUT_641: usize = 1; -fn aiur_fn_641( - inp: [G; IN_641], +const INPUT_SIZE_667: usize = 13; +const IN_667: usize = 13; +const OUT_667: usize = 1; +fn aiur_fn_667( + inp: [G; IN_667], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_641], ExecError> { +) -> Result<[G; OUT_667], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54546,19 +56530,19 @@ fn aiur_fn_641( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = (__v_2 + __v_3); let __v_18: G = (__v_17 + __v_4); let __v_19: G = (__v_18 + __v_16); let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = G::from_u64(1); @@ -54571,7 +56555,7 @@ fn aiur_fn_641( let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_32: G = G::from_u64(0); let __v_33: G = G::from_u64(0); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -54585,26 +56569,26 @@ fn aiur_fn_641( let __v_44: G = G::from_u64(0); let __v_45: G = { let __values: [G; 4] = [__v_43, __v_42, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = G::from_u64(0); - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_640(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_47, __v_35, __v_36, __v_34, __v_9, __v_10, __v_2, __v_3, __v_4, __v_16, __v_7, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __ret: [G; OUT_641] = [__v_49]; - if let Some(result) = record.function_queries[641].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_667] = [__v_49]; + if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_642: usize = 3; -const IN_642: usize = 3; -const OUT_642: usize = 1; -fn aiur_fn_642( - inp: [G; IN_642], +const INPUT_SIZE_668: usize = 3; +const IN_668: usize = 3; +const OUT_668: usize = 1; +fn aiur_fn_668( + inp: [G; IN_668], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_642], ExecError> { +) -> Result<[G; OUT_668], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54621,19 +56605,19 @@ fn aiur_fn_642( 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_642] = [__v_11]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_668] = [__v_11]; + if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_643(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_642(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_10, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_642] = [__v_12]; - if let Some(result) = record.function_queries[642].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_668] = [__v_12]; + if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54643,22 +56627,22 @@ fn aiur_fn_642( }) } -const INPUT_SIZE_643: usize = 5; -const IN_643: usize = 5; -const OUT_643: usize = 1; -fn aiur_fn_643( - inp: [G; IN_643], +const INPUT_SIZE_669: usize = 5; +const IN_669: usize = 5; +const OUT_669: usize = 1; +fn aiur_fn_669( + inp: [G; IN_669], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_643], ExecError> { +) -> Result<[G; OUT_669], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -54712,15 +56696,15 @@ fn aiur_fn_643( match __v_5.as_canonical_u64() { 8u64 => { let __v_53: G = G::from_u64(0); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __ret: [G; OUT_643] = [__v_54]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_669] = [__v_54]; + if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_643] = [__v_4]; - if let Some(result) = record.function_queries[643].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_669] = [__v_4]; + if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54729,15 +56713,15 @@ fn aiur_fn_643( }) } -const INPUT_SIZE_644: usize = 8; -const IN_644: usize = 8; -const OUT_644: usize = 1; -fn aiur_fn_644( - inp: [G; IN_644], +const INPUT_SIZE_670: usize = 8; +const IN_670: usize = 8; +const OUT_670: usize = 1; +fn aiur_fn_670( + inp: [G; IN_670], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_644], ExecError> { +) -> Result<[G; OUT_670], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -54797,16 +56781,16 @@ fn aiur_fn_644( let __v_54: G = __loaded[46]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_644] = [__v_6]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_670] = [__v_6]; + if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_9.as_canonical_u64() { 2u64 => { - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_56.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_57: G = __loaded[0]; @@ -54823,9 +56807,9 @@ fn aiur_fn_644( let __v_68: G = __loaded[11]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_57.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_70.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_71: G = __loaded[0]; @@ -54861,9 +56845,9 @@ fn aiur_fn_644( break '__mc_0 [__v_85]; }, _ => { - let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_599(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_625(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; let __v_85: G = __r_arr[0]; - let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[607].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_607(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_85, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_633(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; let __v_86: G = __r_arr[0]; break '__mc_0 [__v_86]; }, @@ -54884,17 +56868,17 @@ fn aiur_fn_644( let __v_69: G = __mc_out___mc_0[0]; match __v_69.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_644] = [__v_55]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_670] = [__v_55]; + if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_70: G = G::from_u64(1); let __v_71: G = (__v_7 + __v_70); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; - let __ret: [G; OUT_644] = [__v_72]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_670] = [__v_72]; + if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54902,10 +56886,10 @@ fn aiur_fn_644( _ => { let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_644(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; - let __ret: [G; OUT_644] = [__v_57]; - if let Some(result) = record.function_queries[644].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_670] = [__v_57]; + if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -54917,15 +56901,15 @@ fn aiur_fn_644( }) } -const INPUT_SIZE_645: usize = 1; -const IN_645: usize = 1; -const OUT_645: usize = 1; -fn aiur_fn_645( - inp: [G; IN_645], +const INPUT_SIZE_671: usize = 1; +const IN_671: usize = 1; +const OUT_671: usize = 1; +fn aiur_fn_671( + inp: [G; IN_671], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_645], ExecError> { +) -> Result<[G; OUT_671], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; @@ -54940,12 +56924,12 @@ fn aiur_fn_645( 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_645] = [__v_9]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_671] = [__v_9]; + if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_8: G = __loaded[0]; @@ -54972,11 +56956,11 @@ fn aiur_fn_645( }; let __v_20: G = __mc_out___mc_0[0]; let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_645(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_645] = [__v_23]; - if let Some(result) = record.function_queries[645].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_671] = [__v_23]; + if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -54986,20 +56970,20 @@ fn aiur_fn_645( }) } -const INPUT_SIZE_646: usize = 3; -const IN_646: usize = 3; -const OUT_646: usize = 1; -fn aiur_fn_646( - inp: [G; IN_646], +const INPUT_SIZE_672: usize = 3; +const IN_672: usize = 3; +const OUT_672: usize = 1; +fn aiur_fn_672( + inp: [G; IN_672], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_646], ExecError> { +) -> Result<[G; OUT_672], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -55008,7 +56992,7 @@ fn aiur_fn_646( let __v_8: G = __r_arr[5]; let __v_9: G = __r_arr[6]; let __v_10: G = __r_arr[7]; - let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_271(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_271] = unsafe { *(result.output.as_ptr() as *const [G; OUT_271]) }; __ret } } else { aiur_fn_271(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_293(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -55035,21 +57019,21 @@ fn aiur_fn_646( let __v_33: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_646] = [__v_34]; - if let Some(result) = record.function_queries[646].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_672] = [__v_34]; + if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_647: usize = 15; -const IN_647: usize = 15; -const OUT_647: usize = 1; -fn aiur_fn_647( - inp: [G; IN_647], +const INPUT_SIZE_673: usize = 15; +const IN_673: usize = 15; +const OUT_673: usize = 1; +fn aiur_fn_673( + inp: [G; IN_673], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_647], ExecError> { +) -> Result<[G; OUT_673], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55072,12 +57056,12 @@ fn aiur_fn_647( 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_647] = [__v_18]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_673] = [__v_18]; + if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_268(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_268] = unsafe { *(result.output.as_ptr() as *const [G; OUT_268]) }; __ret } } else { aiur_fn_268(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_290(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_17: G = __loaded[0]; @@ -55094,20 +57078,20 @@ fn aiur_fn_647( let __v_28: G = __loaded[11]; match __v_17.as_canonical_u64() { 6u64 => { - let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_646(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_653(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_29, __v_19, __v_23, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(0); let __v_32: G = G::from_u64(1); let __v_33: G = (__v_13 + __v_32); let __v_34: G = G::from_u64(1); let __v_35: G = (__v_14 + __v_34); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_33, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = { let __values: [G; 3] = [__v_31, __v_30, __v_36]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_647] = [__v_37]; - if let Some(result) = record.function_queries[647].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_673] = [__v_37]; + if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55119,15 +57103,15 @@ fn aiur_fn_647( }) } -const INPUT_SIZE_648: usize = 5; -const IN_648: usize = 5; -const OUT_648: usize = 1; -fn aiur_fn_648( - inp: [G; IN_648], +const INPUT_SIZE_674: usize = 5; +const IN_674: usize = 5; +const OUT_674: usize = 1; +fn aiur_fn_674( + inp: [G; IN_674], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_648], ExecError> { +) -> Result<[G; OUT_674], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55136,23 +57120,23 @@ fn aiur_fn_648( let __v_4: G = inp[4]; let __v_5: G = G::from_u64(0); let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_648] = [__v_7]; - if let Some(result) = record.function_queries[648].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_674] = [__v_7]; + if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_649: usize = 8; -const IN_649: usize = 8; -const OUT_649: usize = 1; -fn aiur_fn_649( - inp: [G; IN_649], +const INPUT_SIZE_675: usize = 8; +const IN_675: usize = 8; +const OUT_675: usize = 1; +fn aiur_fn_675( + inp: [G; IN_675], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_649], ExecError> { +) -> Result<[G; OUT_675], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55174,12 +57158,12 @@ fn aiur_fn_649( 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_649] = [__v_16]; - if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_675] = [__v_16]; + if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -55197,28 +57181,28 @@ fn aiur_fn_649( match __v_15.as_canonical_u64() { 5u64 => { let __v_27: G = G::from_u64(0); - let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_9, __v_10, __v_11, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_7, __v_22, __v_23, __v_20, __v_6, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = (__v_6 + __v_29); let __v_31: G = G::from_u64(1); let __v_32: G = (__v_7 + __v_31); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_28, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __ret: [G; OUT_649] = [__v_34]; - if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_675] = [__v_34]; + if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_27: G = G::from_u64(1); let __v_28: G = (__v_7 + __v_27); - let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_649] = [__v_29]; - if let Some(result) = record.function_queries[649].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_675] = [__v_29]; + if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55230,15 +57214,15 @@ fn aiur_fn_649( }) } -const INPUT_SIZE_650: usize = 5; -const IN_650: usize = 5; -const OUT_650: usize = 1; -fn aiur_fn_650( - inp: [G; IN_650], +const INPUT_SIZE_676: usize = 5; +const IN_676: usize = 5; +const OUT_676: usize = 1; +fn aiur_fn_676( + inp: [G; IN_676], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_650], ExecError> { +) -> Result<[G; OUT_676], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55253,23 +57237,23 @@ fn aiur_fn_650( let __v_8: G = (__v_7 - __v_0); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_650] = [__v_10]; - if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_676] = [__v_10]; + if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_650] = [__v_9]; - if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_676] = [__v_9]; + if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55279,8 +57263,8 @@ fn aiur_fn_650( let __v_10: G = (__v_9 - __v_0); let __v_11: G = G::from_u64(0); let __v_12: G = { let __values: [G; 4] = [__v_7, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_650] = [__v_12]; - if let Some(result) = record.function_queries[650].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_676] = [__v_12]; + if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55289,15 +57273,15 @@ fn aiur_fn_650( }) } -const INPUT_SIZE_651: usize = 2; -const IN_651: usize = 2; -const OUT_651: usize = 1; -fn aiur_fn_651( - inp: [G; IN_651], +const INPUT_SIZE_677: usize = 2; +const IN_677: usize = 2; +const OUT_677: usize = 1; +fn aiur_fn_677( + inp: [G; IN_677], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_651], ExecError> { +) -> Result<[G; OUT_677], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55310,30 +57294,30 @@ fn aiur_fn_651( 5u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_1 + __v_6); - let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_651(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_651] = [__v_8]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_677] = [__v_8]; + if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_651] = [__v_1]; - if let Some(result) = record.function_queries[651].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_677] = [__v_1]; + if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_652: usize = 7; -const IN_652: usize = 7; -const OUT_652: usize = 1; -fn aiur_fn_652( - inp: [G; IN_652], +const INPUT_SIZE_678: usize = 7; +const IN_678: usize = 7; +const OUT_678: usize = 1; +fn aiur_fn_678( + inp: [G; IN_678], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_652], ExecError> { +) -> Result<[G; OUT_678], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55344,8 +57328,8 @@ fn aiur_fn_652( let __v_6: G = inp[6]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_652] = [__v_0]; - if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_678] = [__v_0]; + if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55356,26 +57340,26 @@ fn aiur_fn_652( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(1); let __v_15: G = (__v_1 - __v_14); let __v_16: G = G::from_u64(1); let __v_17: G = (__v_6 + __v_16); - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __ret: [G; OUT_652] = [__v_18]; - if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_678] = [__v_18]; + if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -55384,19 +57368,19 @@ fn aiur_fn_652( let __v_18: G = __loaded[3]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_343(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_368(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = G::from_u64(1); let __v_23: G = (__v_1 - __v_22); let __v_24: G = G::from_u64(1); let __v_25: G = (__v_6 + __v_24); - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; - let __ret: [G; OUT_652] = [__v_26]; - if let Some(result) = record.function_queries[652].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_678] = [__v_26]; + if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55410,15 +57394,15 @@ fn aiur_fn_652( }) } -const INPUT_SIZE_653: usize = 13; -const IN_653: usize = 13; -const OUT_653: usize = 1; -fn aiur_fn_653( - inp: [G; IN_653], +const INPUT_SIZE_679: usize = 13; +const IN_679: usize = 13; +const OUT_679: usize = 1; +fn aiur_fn_679( + inp: [G; IN_679], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_653], ExecError> { +) -> Result<[G; OUT_679], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55433,13 +57417,13 @@ fn aiur_fn_653( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_314(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_336(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_9 + __v_10); let __v_15: G = (__v_8 + __v_14); let __v_16: G = (__v_9 + __v_10); let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_652(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); @@ -55451,24 +57435,24 @@ fn aiur_fn_653( let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_28: G = G::from_u64(0); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; let __v_32: G = __r_arr[3]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = (__v_33 + __v_34); let __v_36: G = (__v_15 + __v_35); let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_38, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = (__v_36 - __v_42); @@ -55477,66 +57461,66 @@ fn aiur_fn_653( let __v_46: G = G::from_u64(0); let __v_47: G = G::from_u64(0); let __v_48: G = { let __values: [G; 4] = [__v_46, __v_45, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_48, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(2); let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_659(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); - let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = G::from_u64(3); let __v_57: G = G::from_u64(0); let __v_58: G = { let __values: [G; 4] = [__v_56, __v_49, __v_55, __v_57]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_59: G = G::from_u64(0); - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __v_60: G = __r_arr[0]; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_58, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_61, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __ret: [G; OUT_653] = [__v_62]; - if let Some(result) = record.function_queries[653].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[653].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_679] = [__v_62]; + if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_654: usize = 1; -const IN_654: usize = 1; -const OUT_654: usize = 2; -fn aiur_fn_654( - inp: [G; IN_654], +const INPUT_SIZE_680: usize = 1; +const IN_680: usize = 1; +const OUT_680: usize = 2; +fn aiur_fn_680( + inp: [G; IN_680], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_654], ExecError> { +) -> Result<[G; OUT_680], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_655(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_654] = [__v_6, __v_5]; - if let Some(result) = record.function_queries[654].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_680] = [__v_6, __v_5]; + if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_655: usize = 2; -const IN_655: usize = 2; -const OUT_655: usize = 2; -fn aiur_fn_655( - inp: [G; IN_655], +const INPUT_SIZE_681: usize = 2; +const IN_681: usize = 2; +const OUT_681: usize = 2; +fn aiur_fn_681( + inp: [G; IN_681], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_655], ExecError> { +) -> Result<[G; OUT_681], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55549,31 +57533,31 @@ fn aiur_fn_655( 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_655] = { let __args: [G; IN_655] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_655(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_655] = [__v_8, __v_9]; - if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_681] = [__v_8, __v_9]; + if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_655] = [__v_1, __v_0]; - if let Some(result) = record.function_queries[655].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_681] = [__v_1, __v_0]; + if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_656: usize = 8; -const IN_656: usize = 8; -const OUT_656: usize = 1; -fn aiur_fn_656( - inp: [G; IN_656], +const INPUT_SIZE_682: usize = 8; +const IN_682: usize = 8; +const OUT_682: usize = 1; +fn aiur_fn_682( + inp: [G; IN_682], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_656], ExecError> { +) -> Result<[G; OUT_682], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55592,30 +57576,30 @@ fn aiur_fn_656( 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_656] = [__v_13]; - if let Some(result) = record.function_queries[656].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_682] = [__v_13]; + if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); - let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = (__v_5 + __v_7); let __v_16: G = (__v_6 + __v_15); - let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[766].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_766(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_766] = unsafe { *(result.output.as_ptr() as *const [G; OUT_766]) }; __ret } } else { aiur_fn_766(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_5 - __v_9); let __v_19: G = (__v_18 + __v_7); let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_654(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = (__v_16 + __v_24); let __v_26: G = G::from_u64(1); @@ -55629,37 +57613,37 @@ fn aiur_fn_656( let __v_34: G = G::from_u64(1); let __v_35: G = G::from_u64(1); let __v_36: G = { let __values: [G; 3] = [__v_34, __v_35, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_23, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_39, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(0); let __v_42: G = G::from_u64(0); let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_233(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_43, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_255(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = G::from_u64(0); let __v_46: G = G::from_u64(0); let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_649(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(3); let __v_51: G = G::from_u64(0); let __v_52: G = { let __values: [G; 4] = [__v_50, __v_44, __v_49, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_624(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_52, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_650(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = G::from_u64(0); let __v_55: G = G::from_u64(1); let __v_56: G = (__v_7 + __v_55); - let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_656(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = { let __values: [G; 3] = [__v_54, __v_53, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_656] = [__v_58]; - if let Some(result) = record.function_queries[656].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_682] = [__v_58]; + if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55669,15 +57653,15 @@ fn aiur_fn_656( }) } -const INPUT_SIZE_657: usize = 3; -const IN_657: usize = 3; -const OUT_657: usize = 1; -fn aiur_fn_657( - inp: [G; IN_657], +const INPUT_SIZE_683: usize = 3; +const IN_683: usize = 3; +const OUT_683: usize = 1; +fn aiur_fn_683( + inp: [G; IN_683], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_657], ExecError> { +) -> Result<[G; OUT_683], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55691,19 +57675,19 @@ fn aiur_fn_657( 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_657] = [__v_8]; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_683] = [__v_8]; + if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_657] = [__v_9]; - if let Some(result) = record.function_queries[657].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_683] = [__v_9]; + if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55713,15 +57697,15 @@ fn aiur_fn_657( }) } -const INPUT_SIZE_658: usize = 4; -const IN_658: usize = 4; -const OUT_658: usize = 1; -fn aiur_fn_658( - inp: [G; IN_658], +const INPUT_SIZE_684: usize = 4; +const IN_684: usize = 4; +const OUT_684: usize = 1; +fn aiur_fn_684( + inp: [G; IN_684], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_658], ExecError> { +) -> Result<[G; OUT_684], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55730,8 +57714,8 @@ fn aiur_fn_658( let __v_4: G = (__v_1 - __v_3); match __v_4.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_658] = [__v_0]; - if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_684] = [__v_0]; + if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55746,25 +57730,25 @@ fn aiur_fn_658( 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_658] = { let __args: [G; IN_658] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_658(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __ret: [G; OUT_658] = [__v_16]; - if let Some(result) = record.function_queries[658].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_684] = [__v_16]; + if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_659: usize = 6; -const IN_659: usize = 6; -const OUT_659: usize = 1; -fn aiur_fn_659( - inp: [G; IN_659], +const INPUT_SIZE_685: usize = 6; +const IN_685: usize = 6; +const OUT_685: usize = 1; +fn aiur_fn_685( + inp: [G; IN_685], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_659], ExecError> { +) -> Result<[G; OUT_685], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55777,55 +57761,55 @@ fn aiur_fn_659( 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_631] = { let __args: [G; IN_631] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_657(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_659] = [__v_9]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_9]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_6: G = (__v_3 - __v_2); - let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_647(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_659] = [__v_7]; - if let Some(result) = record.function_queries[659].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_685] = [__v_7]; + if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_660: usize = 3; -const IN_660: usize = 3; -const OUT_660: usize = 2; -fn aiur_fn_660( - inp: [G; IN_660], +const INPUT_SIZE_686: usize = 3; +const IN_686: usize = 3; +const OUT_686: usize = 2; +fn aiur_fn_686( + inp: [G; IN_686], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_660], ExecError> { +) -> Result<[G; OUT_686], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_660] = [__v_3, __v_4]; - if let Some(result) = record.function_queries[660].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_686] = [__v_3, __v_4]; + if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_661: usize = 3; -const IN_661: usize = 3; -const OUT_661: usize = 2; -fn aiur_fn_661( - inp: [G; IN_661], +const INPUT_SIZE_687: usize = 3; +const IN_687: usize = 3; +const OUT_687: usize = 2; +fn aiur_fn_687( + inp: [G; IN_687], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_661], ExecError> { +) -> Result<[G; OUT_687], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55833,7 +57817,7 @@ fn aiur_fn_661( let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_393(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_418(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -55842,11 +57826,11 @@ fn aiur_fn_661( let __v_10: G = __loaded[3]; match __v_7.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __ret: [G; OUT_661] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -55861,18 +57845,18 @@ fn aiur_fn_661( match __v_13.as_canonical_u64() { 2u64 => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_661] = [__v_18, __v_19]; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_18, __v_19]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); let __v_18: G = G::from_u64(0); - let __ret: [G; OUT_661] = [__v_17, __v_18]; - if let Some(result) = record.function_queries[661].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_687] = [__v_17, __v_18]; + if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55881,15 +57865,15 @@ fn aiur_fn_661( }) } -const INPUT_SIZE_662: usize = 5; -const IN_662: usize = 5; -const OUT_662: usize = 2; -fn aiur_fn_662( - inp: [G; IN_662], +const INPUT_SIZE_688: usize = 5; +const IN_688: usize = 5; +const OUT_688: usize = 2; +fn aiur_fn_688( + inp: [G; IN_688], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_662], ExecError> { +) -> Result<[G; OUT_688], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55907,8 +57891,8 @@ fn aiur_fn_662( 1u64 => { let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_662] = [__v_11, __v_12]; - if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_688] = [__v_11, __v_12]; + if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -55920,7 +57904,7 @@ fn aiur_fn_662( break '__mc_0 [__v_12]; }, _ => { - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; break '__mc_0 [__v_12]; }, @@ -55931,18 +57915,18 @@ fn aiur_fn_662( match __v_13.as_canonical_u64() { 1u64 => { let __v_14: G = G::from_u64(1); - let __ret: [G; OUT_662] = [__v_14, __v_4]; - if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_688] = [__v_14, __v_4]; + if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_14: G = G::from_u64(1); let __v_15: G = (__v_4 + __v_14); - let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_662(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __ret: [G; OUT_662] = [__v_16, __v_17]; - if let Some(result) = record.function_queries[662].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_688] = [__v_16, __v_17]; + if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -55954,15 +57938,15 @@ fn aiur_fn_662( }) } -const INPUT_SIZE_663: usize = 3; -const IN_663: usize = 3; -const OUT_663: usize = 1; -fn aiur_fn_663( - inp: [G; IN_663], +const INPUT_SIZE_689: usize = 3; +const IN_689: usize = 3; +const OUT_689: usize = 1; +fn aiur_fn_689( + inp: [G; IN_689], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_663], ExecError> { +) -> Result<[G; OUT_689], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -55974,8 +57958,8 @@ fn aiur_fn_663( match __v_3.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_663] = [__v_6]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_689] = [__v_6]; + if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -55986,28 +57970,28 @@ fn aiur_fn_663( match __v_6.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(0); - let __ret: [G; OUT_663] = [__v_9]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_689] = [__v_9]; + if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_605(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_10, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_631(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[663].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_663(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_663] = [__v_12]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_689] = [__v_12]; + if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_12: G = G::from_u64(0); - let __ret: [G; OUT_663] = [__v_12]; - if let Some(result) = record.function_queries[663].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_689] = [__v_12]; + if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56024,15 +58008,15 @@ fn aiur_fn_663( }) } -const INPUT_SIZE_664: usize = 7; -const IN_664: usize = 7; -const OUT_664: usize = 4; -fn aiur_fn_664( - inp: [G; IN_664], +const INPUT_SIZE_690: usize = 7; +const IN_690: usize = 7; +const OUT_690: usize = 4; +fn aiur_fn_690( + inp: [G; IN_690], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_664], ExecError> { +) -> Result<[G; OUT_690], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56049,7 +58033,7 @@ fn aiur_fn_664( match __v_7.as_canonical_u64() { 5u64 => { let __v_11: G = (__v_6 + __v_5); - let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_660(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = G::from_u64(0); @@ -56062,53 +58046,53 @@ fn aiur_fn_664( let __v_19: G = { let __values: [G; 3] = [__v_18, __v_13, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_5 + __v_20); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; - let __ret: [G; OUT_664] = [__v_22, __v_23, __v_24, __v_25]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_690] = [__v_22, __v_23, __v_24, __v_25]; + if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_16: G = G::from_u64(1); let __v_17: G = (__v_5 + __v_16); - let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_664(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; let __v_21: G = __r_arr[3]; - let __ret: [G; OUT_664] = [__v_18, __v_19, __v_20, __v_21]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_690] = [__v_18, __v_19, __v_20, __v_21]; + if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[762].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_762(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_762] = unsafe { *(result.output.as_ptr() as *const [G; OUT_762]) }; __ret } } else { aiur_fn_762(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_664] = [__v_11, __v_12, __v_13, __v_0]; - if let Some(result) = record.function_queries[664].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_690] = [__v_11, __v_12, __v_13, __v_0]; + if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_665: usize = 4; -const IN_665: usize = 4; -const OUT_665: usize = 1; -fn aiur_fn_665( - inp: [G; IN_665], +const INPUT_SIZE_691: usize = 4; +const IN_691: usize = 4; +const OUT_691: usize = 1; +fn aiur_fn_691( + inp: [G; IN_691], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_665], ExecError> { +) -> Result<[G; OUT_691], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56126,12 +58110,12 @@ fn aiur_fn_665( 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_665] = [__v_12]; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_691] = [__v_12]; + if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_11: G = __loaded[0]; @@ -56148,26 +58132,26 @@ fn aiur_fn_665( let __v_22: G = __loaded[11]; match __v_11.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_629(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_655(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(0); - let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_337(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_359(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); let __v_27: G = G::from_u64(1); let __v_28: G = (__v_3 + __v_27); - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = { let __values: [G; 3] = [__v_26, __v_25, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_665] = [__v_30]; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_691] = [__v_30]; + if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_665(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_665] = [__v_23]; - if let Some(result) = record.function_queries[665].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_691] = [__v_23]; + if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56179,15 +58163,15 @@ fn aiur_fn_665( }) } -const INPUT_SIZE_666: usize = 13; -const IN_666: usize = 13; -const OUT_666: usize = 0; -fn aiur_fn_666( - inp: [G; IN_666], +const INPUT_SIZE_692: usize = 13; +const IN_692: usize = 13; +const OUT_692: usize = 0; +fn aiur_fn_692( + inp: [G; IN_692], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_666], ExecError> { +) -> Result<[G; OUT_692], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56204,9 +58188,9 @@ fn aiur_fn_666( let __v_12: G = inp[12]; match __v_0.as_canonical_u64() { 7u64 => { - let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[597].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_597(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_597] = unsafe { *(result.output.as_ptr() as *const [G; OUT_597]) }; __ret } } else { aiur_fn_597(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_623(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_15: G = __loaded[0]; @@ -56223,9 +58207,9 @@ fn aiur_fn_666( let __v_26: G = __loaded[11]; match __v_15.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[595].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_595(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_595] = unsafe { *(result.output.as_ptr() as *const [G; OUT_595]) }; __ret } } else { aiur_fn_595(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_621(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__v_10, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[1].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_1(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; @@ -56238,11 +58222,11 @@ fn aiur_fn_666( let __v_36: G = (__v_34 + __v_35); let __v_37: G = G::from_u64(1); let __v_38: G = (__v_36 + __v_37); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = (__v_5 + __v_6); let __v_41: G = (__v_3 + __v_40); - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_7, __v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() { 1u64 => { break '__mc_0 []; @@ -56255,15 +58239,15 @@ fn aiur_fn_666( return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("recursor index count differs from its inductive's".to_string()) }); } let __v_42: G = (__v_18 + __v_19); - let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[667].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_667(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_619(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; - let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_585(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_750(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_611(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; if (__v_43 != __v_20) { return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) }); @@ -56271,9 +58255,9 @@ fn aiur_fn_666( if (__v_8 != __v_42) { return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_42.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) }); } - let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_635(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_666] = []; - if let Some(result) = record.function_queries[666].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_661(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_692] = []; + if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56288,15 +58272,15 @@ fn aiur_fn_666( }) } -const INPUT_SIZE_667: usize = 6; -const IN_667: usize = 6; -const OUT_667: usize = 0; -fn aiur_fn_667( - inp: [G; IN_667], +const INPUT_SIZE_693: usize = 6; +const IN_693: usize = 6; +const OUT_693: usize = 0; +fn aiur_fn_693( + inp: [G; IN_693], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_667], ExecError> { +) -> Result<[G; OUT_693], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56307,7 +58291,7 @@ fn aiur_fn_667( let __v_6: G = (__v_3 + __v_4); let __v_7: G = (__v_2 + __v_6); let __v_8: G = (__v_1 + __v_7); - let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_560(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_10: G = __loaded[0]; @@ -56319,13 +58303,13 @@ fn aiur_fn_667( let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_111(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; if (__v_16 != __v_5) { return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("recursor major premise has the wrong number of spine args".to_string()) }); } - let __ret: [G; OUT_667] = []; - if let Some(result) = record.function_queries[667].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_693] = []; + if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56335,15 +58319,15 @@ fn aiur_fn_667( }) } -const INPUT_SIZE_668: usize = 2; -const IN_668: usize = 2; -const OUT_668: usize = 1; -fn aiur_fn_668( - inp: [G; IN_668], +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_668], ExecError> { +) -> Result<[G; OUT_694], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56353,8 +58337,8 @@ fn aiur_fn_668( 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_668] = [__v_5]; - if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_694] = [__v_5]; + if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56364,26 +58348,26 @@ fn aiur_fn_668( 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_668] = { let __args: [G; IN_668] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_668(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; let __v_10: G = { let __values: [G; 3] = [__v_3, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_668] = [__v_10]; - if let Some(result) = record.function_queries[668].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_694] = [__v_10]; + if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_669: usize = 3; -const IN_669: usize = 3; -const OUT_669: usize = 0; -fn aiur_fn_669( - inp: [G; IN_669], +const INPUT_SIZE_695: usize = 3; +const IN_695: usize = 3; +const OUT_695: usize = 0; +fn aiur_fn_695( + inp: [G; IN_695], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_669], ExecError> { +) -> Result<[G; OUT_695], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56396,18 +58380,18 @@ fn aiur_fn_669( let __v_7: G = __loaded[4]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_669] = []; - if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_695] = []; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_4.as_canonical_u64() { _ => { let __v_8: G = (__v_1 + __v_5); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_669(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_669] = []; - if let Some(result) = record.function_queries[669].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_695] = []; + if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56419,15 +58403,15 @@ fn aiur_fn_669( }) } -const INPUT_SIZE_670: usize = 4; -const IN_670: usize = 4; -const OUT_670: usize = 3; -fn aiur_fn_670( - inp: [G; IN_670], +const INPUT_SIZE_696: usize = 4; +const IN_696: usize = 4; +const OUT_696: usize = 3; +fn aiur_fn_696( + inp: [G; IN_696], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_670], ExecError> { +) -> Result<[G; OUT_696], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56435,8 +58419,8 @@ fn aiur_fn_670( let __v_3: G = inp[3]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_670] = [__v_0, __v_2, __v_3]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_696] = [__v_0, __v_2, __v_3]; + if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56453,17 +58437,17 @@ fn aiur_fn_670( let __v_11: G = (__v_2 + __v_10); let __v_12: G = G::from_u64(0); let __v_13: G = { let __values: [G; 3] = [__v_12, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_670(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; - let __ret: [G; OUT_670] = [__v_14, __v_15, __v_16]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_696] = [__v_14, __v_15, __v_16]; + if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_670] = [__v_0, __v_2, __v_3]; - if let Some(result) = record.function_queries[670].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_696] = [__v_0, __v_2, __v_3]; + if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56472,15 +58456,15 @@ fn aiur_fn_670( }) } -const INPUT_SIZE_671: usize = 13; -const IN_671: usize = 13; -const OUT_671: usize = 0; -fn aiur_fn_671( - inp: [G; IN_671], +const INPUT_SIZE_697: usize = 13; +const IN_697: usize = 13; +const OUT_697: usize = 0; +fn aiur_fn_697( + inp: [G; IN_697], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_671], ExecError> { +) -> Result<[G; OUT_697], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -56495,58 +58479,58 @@ fn aiur_fn_671( let __v_10: G = inp[10]; let __v_11: G = inp[11]; let __v_12: G = inp[12]; - let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_550(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_576(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_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_471] = { let __args: [G; IN_471] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_671] = []; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_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_472] = { let __args: [G; IN_472] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_671] = []; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_20: G = G::from_u64(0); let __v_21: G = G::from_u64(0); let __v_22: G = { let __values: [G; 3] = [__v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_302(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_324(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = G::from_u64(1); if (__v_23 != __v_24) { @@ -56555,71 +58539,71 @@ fn aiur_fn_671( let __v_25: G = G::from_u64(1); let __v_26: G = G::from_u64(1); let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_671] = []; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_15: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_16: G = G::from_u64(1); let __v_17: G = G::from_u64(1); let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; let __v_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_472] = { let __args: [G; IN_472] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_472(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_671] = []; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_500(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_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_471] = { let __args: [G; IN_471] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_559(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_671] = []; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_585(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_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_471] = { let __args: [G; IN_471] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_583(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __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[586].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_586(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_671] = []; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[609].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_609(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_612(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_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_471] = { let __args: [G; IN_471] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_267(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_267] = unsafe { *(result.output.as_ptr() as *const [G; OUT_267]) }; __ret } } else { aiur_fn_267(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_289(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; @@ -56636,15 +58620,15 @@ fn aiur_fn_671( let __v_31: G = __loaded[11]; match __v_20.as_canonical_u64() { 5u64 => { - let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_566(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_564(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_592(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_590(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; let __v_32: G = (__v_23 + __v_24); let __v_33: G = G::from_u64(1); let __v_34: G = G::from_u64(1); let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_567(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_593(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_570(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_596(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; if (__v_6 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_23.as_canonical_u64(), msg: Some("ctor parameter count differs from its inductive's".to_string()) }); } @@ -56653,14 +58637,14 @@ fn aiur_fn_671( let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_582(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_671] = []; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_608(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_671] = []; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56672,17 +58656,17 @@ fn aiur_fn_671( }, 7u64 => { let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_555(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_581(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; let __v_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_471] = { let __args: [G; IN_471] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_471(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_499(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_552(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_549(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __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[666].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_666(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_671] = []; - if let Some(result) = record.function_queries[671].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_578(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_575(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_697] = []; + if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56692,18 +58676,18 @@ fn aiur_fn_671( }) } -const INPUT_SIZE_672: usize = 1; -const IN_672: usize = 1; -const OUT_672: usize = 0; -fn aiur_fn_672( - inp: [G; IN_672], +const INPUT_SIZE_698: usize = 1; +const IN_698: usize = 1; +const OUT_698: usize = 0; +fn aiur_fn_698( + inp: [G; IN_698], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_672], ExecError> { +) -> Result<[G; OUT_698], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; @@ -56718,22 +58702,22 @@ fn aiur_fn_672( let __v_11: G = __loaded[9]; let __v_12: G = __loaded[10]; let __v_13: G = __loaded[11]; - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_672] = []; - if let Some(result) = record.function_queries[672].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_698] = []; + if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_673: usize = 1; -const IN_673: usize = 1; -const OUT_673: usize = 1; -fn aiur_fn_673( - inp: [G; IN_673], +const INPUT_SIZE_699: usize = 1; +const IN_699: usize = 1; +const OUT_699: usize = 1; +fn aiur_fn_699( + inp: [G; IN_699], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_673], ExecError> { +) -> Result<[G; OUT_699], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; @@ -56764,90 +58748,90 @@ fn aiur_fn_673( let __v_22: G = G::from_u64(1); let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = { let __values: [G; 3] = [__v_19, __v_20, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_673] = [__v_24]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_24]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { let __v_19: G = G::from_u64(0); let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_16(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = { let __values: [G; 3] = [__v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_673] = [__v_22]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_22]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_673] = [__v_21]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_21]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_673] = [__v_21]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_21]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_673] = [__v_21]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_21]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 10u64 => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_19, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_673] = [__v_23]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_23]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_673] = [__v_21]; - if let Some(result) = record.function_queries[673].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_699] = [__v_21]; + if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_674: usize = 1; -const IN_674: usize = 1; -const OUT_674: usize = 1; -fn aiur_fn_674( - inp: [G; IN_674], +const INPUT_SIZE_700: usize = 1; +const IN_700: usize = 1; +const OUT_700: usize = 1; +fn aiur_fn_700( + inp: [G; IN_700], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_674], ExecError> { +) -> Result<[G; OUT_700], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -56859,19 +58843,19 @@ fn aiur_fn_674( 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_674] = [__v_6]; - if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_6]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_674] = [__v_6]; - if let Some(result) = record.function_queries[674].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_700] = [__v_6]; + if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -56881,15 +58865,15 @@ fn aiur_fn_674( }) } -const INPUT_SIZE_675: usize = 1; -const IN_675: usize = 1; -const OUT_675: usize = 1; -fn aiur_fn_675( - inp: [G; IN_675], +const INPUT_SIZE_701: usize = 1; +const IN_701: usize = 1; +const OUT_701: usize = 1; +fn aiur_fn_701( + inp: [G; IN_701], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_675], ExecError> { +) -> Result<[G; OUT_701], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; @@ -56909,21 +58893,21 @@ fn aiur_fn_675( 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_675] = [__v_14]; - if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_701] = [__v_14]; + if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_675] = [__v_14]; - if let Some(result) = record.function_queries[675].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[675].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_701] = [__v_14]; + if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -56935,15 +58919,15 @@ fn aiur_fn_675( }) } -const INPUT_SIZE_676: usize = 1; -const IN_676: usize = 1; -const OUT_676: usize = 1; -fn aiur_fn_676( - inp: [G; IN_676], +const INPUT_SIZE_702: usize = 1; +const IN_702: usize = 1; +const OUT_702: usize = 1; +fn aiur_fn_702( + inp: [G; IN_702], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_676], ExecError> { +) -> Result<[G; OUT_702], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -56988,21 +58972,21 @@ fn aiur_fn_676( let __v_37: G = G::from_u64(1); let __v_38: G = G::from_u64(1); let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_676] = [__v_39]; - if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_702] = [__v_39]; + if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __ret: [G; OUT_676] = [__v_39]; - if let Some(result) = record.function_queries[676].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_702] = [__v_39]; + if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57014,15 +58998,15 @@ fn aiur_fn_676( }) } -const INPUT_SIZE_677: usize = 1; -const IN_677: usize = 1; -const OUT_677: usize = 1; -fn aiur_fn_677( - inp: [G; IN_677], +const INPUT_SIZE_703: usize = 1; +const IN_703: usize = 1; +const OUT_703: usize = 1; +fn aiur_fn_703( + inp: [G; IN_703], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_677], ExecError> { +) -> Result<[G; OUT_703], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; @@ -57078,8 +59062,8 @@ fn aiur_fn_677( let __v_48: G = G::from_u64(1); let __v_49: G = G::from_u64(1); let __v_50: G = { let __values: [G; 3] = [__v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_677] = [__v_50]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_703] = [__v_50]; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -57087,18 +59071,18 @@ fn aiur_fn_677( 0u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_677] = [__v_52]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_703] = [__v_52]; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57106,18 +59090,18 @@ fn aiur_fn_677( 1u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_676(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_677] = [__v_52]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_703] = [__v_52]; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57125,18 +59109,18 @@ fn aiur_fn_677( 2u64 => { match __v_3.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_677] = [__v_52]; - if let Some(result) = record.function_queries[677].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_703] = [__v_52]; + if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57153,15 +59137,15 @@ fn aiur_fn_677( }) } -const INPUT_SIZE_678: usize = 48; -const IN_678: usize = 48; -const OUT_678: usize = 1; -fn aiur_fn_678( - inp: [G; IN_678], +const INPUT_SIZE_704: usize = 48; +const IN_704: usize = 48; +const OUT_704: usize = 1; +fn aiur_fn_704( + inp: [G; IN_704], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_678], ExecError> { +) -> Result<[G; OUT_704], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57213,22 +59197,22 @@ fn aiur_fn_678( let __v_47: G = inp[47]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[674].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_674(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; match __v_0.as_canonical_u64() { 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_678] = [__v_52]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_52]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57236,16 +59220,16 @@ fn aiur_fn_678( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_675(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; - let __ret: [G; OUT_678] = [__v_52]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_52]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57253,12 +59237,12 @@ fn aiur_fn_678( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_678] = [__v_50]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_50]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57266,28 +59250,28 @@ fn aiur_fn_678( 3u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_673(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_678] = [__v_50]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_50]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }, 8u64 => { - let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_677(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; - let __ret: [G; OUT_678] = [__v_50]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_50]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __ret: [G; OUT_678] = [__v_48]; - if let Some(result) = record.function_queries[678].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_704] = [__v_48]; + if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57296,15 +59280,15 @@ fn aiur_fn_678( }) } -const INPUT_SIZE_679: usize = 2; -const IN_679: usize = 2; -const OUT_679: usize = 1; -fn aiur_fn_679( - inp: [G; IN_679], +const INPUT_SIZE_705: usize = 2; +const IN_705: usize = 2; +const OUT_705: usize = 1; +fn aiur_fn_705( + inp: [G; IN_705], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_679], ExecError> { +) -> Result<[G; OUT_705], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57315,8 +59299,8 @@ fn aiur_fn_679( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_679] = [__v_5]; - if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_705] = [__v_5]; + if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -57324,15 +59308,15 @@ fn aiur_fn_679( match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); - let __ret: [G; OUT_679] = [__v_6]; - if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_705] = [__v_6]; + if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_679] = [__v_6]; - if let Some(result) = record.function_queries[679].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_705] = [__v_6]; + if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -57344,18 +59328,18 @@ fn aiur_fn_679( }) } -const INPUT_SIZE_680: usize = 1; -const IN_680: usize = 1; -const OUT_680: usize = 0; -fn aiur_fn_680( - inp: [G; IN_680], +const INPUT_SIZE_706: usize = 1; +const IN_706: usize = 1; +const OUT_706: usize = 0; +fn aiur_fn_706( + inp: [G; IN_706], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_680], ExecError> { +) -> Result<[G; OUT_706], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -57409,14 +59393,14 @@ fn aiur_fn_680( let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() { 8u64 => { let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, 7u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -57424,8 +59408,8 @@ fn aiur_fn_680( 6u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -57433,8 +59417,8 @@ fn aiur_fn_680( 4u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } @@ -57442,39 +59426,39 @@ fn aiur_fn_680( 5u64 => { match __v_2.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }, _ => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, } }; - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = G::from_u64(0); - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_680] = []; - if let Some(result) = record.function_queries[680].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_681: usize = 3; -const IN_681: usize = 3; -const OUT_681: usize = 0; -fn aiur_fn_681( - inp: [G; IN_681], +const INPUT_SIZE_707: usize = 3; +const IN_707: usize = 3; +const OUT_707: usize = 0; +fn aiur_fn_707( + inp: [G; IN_707], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_681], ExecError> { +) -> Result<[G; OUT_707], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57485,16 +59469,16 @@ fn aiur_fn_681( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_681] = []; - if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_707] = []; + if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -57504,9 +59488,9 @@ fn aiur_fn_681( }; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 + __v_7); - let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_681(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_681] = []; - if let Some(result) = record.function_queries[681].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_707] = []; + if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57516,15 +59500,15 @@ fn aiur_fn_681( }) } -const INPUT_SIZE_682: usize = 4; -const IN_682: usize = 4; -const OUT_682: usize = 0; -fn aiur_fn_682( - inp: [G; IN_682], +const INPUT_SIZE_708: usize = 4; +const IN_708: usize = 4; +const OUT_708: usize = 0; +fn aiur_fn_708( + inp: [G; IN_708], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_682], ExecError> { +) -> Result<[G; OUT_708], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57580,17 +59564,17 @@ fn aiur_fn_682( let __v_50: G = __loaded[46]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_682] = []; - if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_708] = []; + if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_683(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0, __v_1, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; let __v_51: G = G::from_u64(1); let __v_52: G = (__v_3 + __v_51); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_682] = []; - if let Some(result) = record.function_queries[682].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_708] = []; + if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57600,15 +59584,15 @@ fn aiur_fn_682( }) } -const INPUT_SIZE_683: usize = 48; -const IN_683: usize = 48; -const OUT_683: usize = 0; -fn aiur_fn_683( - inp: [G; IN_683], +const INPUT_SIZE_709: usize = 48; +const IN_709: usize = 48; +const OUT_709: usize = 0; +fn aiur_fn_709( + inp: [G; IN_709], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_683], ExecError> { +) -> Result<[G; OUT_709], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57658,9 +59642,9 @@ fn aiur_fn_683( let __v_45: G = inp[45]; let __v_46: G = inp[46]; let __v_47: G = inp[47]; - let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_272(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_294(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; - let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_265(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_265] = unsafe { *(result.output.as_ptr() as *const [G; OUT_265]) }; __ret } } else { aiur_fn_265(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_287(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __loaded: [G; 12] = { let __mq = record.memory_queries.get_mut(&12).ok_or(ExecError::InvalidMemorySize(12))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr }; let __v_50: G = __loaded[0]; @@ -57675,22 +59659,22 @@ fn aiur_fn_683( let __v_59: G = __loaded[9]; let __v_60: G = __loaded[10]; let __v_61: G = __loaded[11]; - let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[671].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_671(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_683] = []; - if let Some(result) = record.function_queries[683].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_709] = []; + if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_684: usize = 1; -const IN_684: usize = 1; -const OUT_684: usize = 1; -fn aiur_fn_684( - inp: [G; IN_684], +const INPUT_SIZE_710: usize = 1; +const IN_710: usize = 1; +const OUT_710: usize = 1; +fn aiur_fn_710( + inp: [G; IN_710], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_684], ExecError> { +) -> Result<[G; OUT_710], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); @@ -57703,21 +59687,21 @@ fn aiur_fn_684( let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_684] = [__v_8]; - if let Some(result) = record.function_queries[684].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_710] = [__v_8]; + if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_685: usize = 2; -const IN_685: usize = 2; -const OUT_685: usize = 1; -fn aiur_fn_685( - inp: [G; IN_685], +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_685], ExecError> { +) -> Result<[G; OUT_711], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -57733,21 +59717,21 @@ fn aiur_fn_685( let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_685] = [__v_10]; - if let Some(result) = record.function_queries[685].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_711] = [__v_10]; + if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_686: usize = 1; -const IN_686: usize = 1; -const OUT_686: usize = 3; -fn aiur_fn_686( - inp: [G; IN_686], +const INPUT_SIZE_712: usize = 1; +const IN_712: usize = 1; +const OUT_712: usize = 3; +fn aiur_fn_712( + inp: [G; IN_712], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_686], ExecError> { +) -> Result<[G; OUT_712], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -57758,15 +59742,15 @@ fn aiur_fn_686( let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_684(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(0); let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_686] = [__v_5, __v_10, __v_4]; - if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_712] = [__v_5, __v_10, __v_4]; + if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -57806,25 +59790,25 @@ fn aiur_fn_686( 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_686] = [__v_35, __v_38, __v_2]; - if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_712] = [__v_35, __v_38, __v_2]; + if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; - let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; - let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[685].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_685(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; - let __ret: [G; OUT_686] = [__v_9, __v_10, __v_8]; - if let Some(result) = record.function_queries[686].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_712] = [__v_9, __v_10, __v_8]; + if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -57834,15 +59818,15 @@ fn aiur_fn_686( }) } -const INPUT_SIZE_687: usize = 1; -const IN_687: usize = 1; -const OUT_687: usize = 1; -fn aiur_fn_687( - inp: [G; IN_687], +const INPUT_SIZE_713: usize = 1; +const IN_713: usize = 1; +const OUT_713: usize = 1; +fn aiur_fn_713( + inp: [G; IN_713], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_687], ExecError> { +) -> Result<[G; OUT_713], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; @@ -57896,7 +59880,7 @@ fn aiur_fn_687( 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_686] = { let __args: [G; IN_686] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_686(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -58052,21 +60036,21 @@ fn aiur_fn_687( if (__v_82 != __v_32) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) }); } - let __ret: [G; OUT_687] = [__v_49]; - if let Some(result) = record.function_queries[687].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_713] = [__v_49]; + if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_688: usize = 7; -const IN_688: usize = 7; -const OUT_688: usize = 6; -fn aiur_fn_688( - inp: [G; IN_688], +const INPUT_SIZE_714: usize = 7; +const IN_714: usize = 7; +const OUT_714: usize = 6; +fn aiur_fn_714( + inp: [G; IN_714], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_688], ExecError> { +) -> Result<[G; OUT_714], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58081,28 +60065,28 @@ fn aiur_fn_688( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_688] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; - if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_714] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_10: G = G::from_u64(1); - let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[751].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_751(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_751] = unsafe { *(result.output.as_ptr() as *const [G; OUT_751]) }; __ret } } else { aiur_fn_751(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[777].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_777(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_777] = unsafe { *(result.output.as_ptr() as *const [G; OUT_777]) }; __ret } } else { aiur_fn_777(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; let __v_14: G = __r_arr[3]; let __v_15: G = __r_arr[4]; let __v_16: G = __r_arr[5]; - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; let __v_20: G = __r_arr[3]; let __v_21: G = __r_arr[4]; let __v_22: G = __r_arr[5]; - let __ret: [G; OUT_688] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; - if let Some(result) = record.function_queries[688].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_714] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58112,15 +60096,15 @@ fn aiur_fn_688( }) } -const INPUT_SIZE_689: usize = 7; -const IN_689: usize = 7; -const OUT_689: usize = 1; -fn aiur_fn_689( - inp: [G; IN_689], +const INPUT_SIZE_715: usize = 7; +const IN_715: usize = 7; +const OUT_715: usize = 1; +fn aiur_fn_715( + inp: [G; IN_715], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_689], ExecError> { +) -> Result<[G; OUT_715], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58130,23 +60114,23 @@ fn aiur_fn_689( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_689] = [__v_8]; - if let Some(result) = record.function_queries[689].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_715] = [__v_8]; + if let Some(result) = record.function_queries[715].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_690: usize = 14; -const IN_690: usize = 14; -const OUT_690: usize = 0; -fn aiur_fn_690( - inp: [G; IN_690], +const INPUT_SIZE_716: usize = 14; +const IN_716: usize = 14; +const OUT_716: usize = 0; +fn aiur_fn_716( + inp: [G; IN_716], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_690], ExecError> { +) -> Result<[G; OUT_716], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58162,18 +60146,18 @@ fn aiur_fn_690( let __v_11: G = inp[11]; let __v_12: G = inp[12]; let __v_13: G = inp[13]; - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; match __v_14.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_690] = []; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_716] = []; + if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_689(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(1); if (__v_15 != __v_16) { @@ -58186,7 +60170,7 @@ fn aiur_fn_690( }, } }; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -58240,14 +60224,14 @@ fn aiur_fn_690( let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_15.as_canonical_u64() { 8u64 => { let __v_63: G = G::from_u64(0); - let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_682(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, 7u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -58255,8 +60239,8 @@ fn aiur_fn_690( 6u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -58264,8 +60248,8 @@ fn aiur_fn_690( 4u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_32, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } @@ -58273,24 +60257,24 @@ fn aiur_fn_690( 5u64 => { match __v_16.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }, _ => { - let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_672(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; break '__mc_1 []; }, } }; - let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_678(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = G::from_u64(0); - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_690] = []; - if let Some(result) = record.function_queries[690].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_61, __v_63, __v_64, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_716] = []; + if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -58299,15 +60283,15 @@ fn aiur_fn_690( }) } -const INPUT_SIZE_691: usize = 16; -const IN_691: usize = 16; -const OUT_691: usize = 0; -fn aiur_fn_691( - inp: [G; IN_691], +const INPUT_SIZE_717: usize = 16; +const IN_717: usize = 16; +const OUT_717: usize = 0; +fn aiur_fn_717( + inp: [G; IN_717], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_691], ExecError> { +) -> Result<[G; OUT_717], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58331,16 +60315,16 @@ fn aiur_fn_691( let __v_18: G = __loaded[2]; match __v_16.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_691] = []; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_717] = []; + if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_679(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_19.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_17, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; break '__mc_0 []; }, _ => { @@ -58350,9 +60334,9 @@ fn aiur_fn_691( }; let __v_20: G = G::from_u64(1); let __v_21: G = (__v_2 + __v_20); - let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_691(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_691] = []; - if let Some(result) = record.function_queries[691].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18, __v_1, __v_21, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_717] = []; + if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58362,15 +60346,15 @@ fn aiur_fn_691( }) } -const INPUT_SIZE_692: usize = 13; -const IN_692: usize = 13; -const OUT_692: usize = 0; -fn aiur_fn_692( - inp: [G; IN_692], +const INPUT_SIZE_718: usize = 13; +const IN_718: usize = 13; +const OUT_718: usize = 0; +fn aiur_fn_718( + inp: [G; IN_718], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_692], ExecError> { +) -> Result<[G; OUT_718], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58391,16 +60375,16 @@ fn aiur_fn_692( let __v_15: G = __loaded[2]; match __v_13.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_692] = []; - if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_718] = []; + if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_16: G = G::from_u64(1); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_692] = []; - if let Some(result) = record.function_queries[692].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_718] = []; + if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58410,20 +60394,20 @@ fn aiur_fn_692( }) } -const INPUT_SIZE_693: usize = 3; -const IN_693: usize = 3; -const OUT_693: usize = 0; -fn aiur_fn_693( - inp: [G; IN_693], +const INPUT_SIZE_719: usize = 3; +const IN_719: usize = 3; +const OUT_719: usize = 0; +fn aiur_fn_719( + inp: [G; IN_719], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_693], ExecError> { +) -> Result<[G; OUT_719], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() { 1u64 => { @@ -58433,7 +60417,7 @@ fn aiur_fn_693( break '__mc_0 [__v_6]; }, 0u64 => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; break '__mc_0 [__v_4]; }, @@ -58445,7 +60429,7 @@ fn aiur_fn_693( let __v_4: G = __mc_out___mc_0[0]; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; let __v_9: G = __r_arr[2]; @@ -58454,29 +60438,29 @@ fn aiur_fn_693( let __v_12: G = __r_arr[5]; let __v_13: G = G::from_u64(1); let __v_14: G = G::from_u64(1); - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; - let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_692(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_693] = []; - if let Some(result) = record.function_queries[693].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_719] = []; + if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_694: usize = 1; -const IN_694: usize = 1; -const OUT_694: usize = 3; -fn aiur_fn_694( - inp: [G; IN_694], +const INPUT_SIZE_720: usize = 1; +const IN_720: usize = 1; +const OUT_720: usize = 3; +fn aiur_fn_720( + inp: [G; IN_720], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_694], ExecError> { +) -> Result<[G; OUT_720], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -58486,8 +60470,8 @@ fn aiur_fn_694( 0u64 => { let __v_3: G = G::from_u64(1); let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_694] = [__v_3, __v_4, __v_2]; - if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_3, __v_4, __v_2]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { @@ -58495,8 +60479,8 @@ fn aiur_fn_694( 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_694] = [__v_5, __v_3, __v_4]; - if let Some(result) = record.function_queries[694].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_720] = [__v_5, __v_3, __v_4]; + if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58506,15 +60490,15 @@ fn aiur_fn_694( }) } -const INPUT_SIZE_695: usize = 2; -const IN_695: usize = 2; -const OUT_695: usize = 10; -fn aiur_fn_695( - inp: [G; IN_695], +const INPUT_SIZE_721: usize = 2; +const IN_721: usize = 2; +const OUT_721: usize = 10; +fn aiur_fn_721( + inp: [G; IN_721], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_695], ExecError> { +) -> Result<[G; OUT_721], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58522,8 +60506,8 @@ fn aiur_fn_695( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_695] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58538,23 +60522,23 @@ fn aiur_fn_695( 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_695] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; - if let Some(result) = record.function_queries[695].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_721] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_696: usize = 2; -const IN_696: usize = 2; -const OUT_696: usize = 3; -fn aiur_fn_696( - inp: [G; IN_696], +const INPUT_SIZE_722: usize = 2; +const IN_722: usize = 2; +const OUT_722: usize = 3; +fn aiur_fn_722( + inp: [G; IN_722], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_696], ExecError> { +) -> Result<[G; OUT_722], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58562,8 +60546,8 @@ fn aiur_fn_696( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_696] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_722] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58571,23 +60555,23 @@ fn aiur_fn_696( 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_696] = [__v_4, __v_2, __v_3]; - if let Some(result) = record.function_queries[696].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_722] = [__v_4, __v_2, __v_3]; + if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_697: usize = 2; -const IN_697: usize = 2; -const OUT_697: usize = 3; -fn aiur_fn_697( - inp: [G; IN_697], +const INPUT_SIZE_723: usize = 2; +const IN_723: usize = 2; +const OUT_723: usize = 3; +fn aiur_fn_723( + inp: [G; IN_723], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_697], ExecError> { +) -> Result<[G; OUT_723], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58595,8 +60579,8 @@ fn aiur_fn_697( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_697] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_723] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58604,23 +60588,23 @@ fn aiur_fn_697( 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_697] = [__v_4, __v_2, __v_3]; - if let Some(result) = record.function_queries[697].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_723] = [__v_4, __v_2, __v_3]; + if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_698: usize = 2; -const IN_698: usize = 2; -const OUT_698: usize = 3; -fn aiur_fn_698( - inp: [G; IN_698], +const INPUT_SIZE_724: usize = 2; +const IN_724: usize = 2; +const OUT_724: usize = 3; +fn aiur_fn_724( + inp: [G; IN_724], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_698], ExecError> { +) -> Result<[G; OUT_724], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58628,8 +60612,8 @@ fn aiur_fn_698( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_698] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_724] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58640,22 +60624,22 @@ fn aiur_fn_698( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_698] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_698] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_698] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[698].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_724] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58667,15 +60651,15 @@ fn aiur_fn_698( }) } -const INPUT_SIZE_699: usize = 2; -const IN_699: usize = 2; -const OUT_699: usize = 3; -fn aiur_fn_699( - inp: [G; IN_699], +const INPUT_SIZE_725: usize = 2; +const IN_725: usize = 2; +const OUT_725: usize = 3; +fn aiur_fn_725( + inp: [G; IN_725], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_699], ExecError> { +) -> Result<[G; OUT_725], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58683,8 +60667,8 @@ fn aiur_fn_699( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_699] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58695,29 +60679,29 @@ fn aiur_fn_699( 0u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_699] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_699] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(2); - let __ret: [G; OUT_699] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { let __v_4: G = G::from_u64(0); let __v_5: G = G::from_u64(3); - let __ret: [G; OUT_699] = [__v_4, __v_5, __v_3]; - if let Some(result) = record.function_queries[699].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_725] = [__v_4, __v_5, __v_3]; + if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58729,15 +60713,15 @@ fn aiur_fn_699( }) } -const INPUT_SIZE_700: usize = 9; -const IN_700: usize = 9; -const OUT_700: usize = 2; -fn aiur_fn_700( - inp: [G; IN_700], +const INPUT_SIZE_726: usize = 9; +const IN_726: usize = 9; +const OUT_726: usize = 2; +fn aiur_fn_726( + inp: [G; IN_726], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_700], ExecError> { +) -> Result<[G; OUT_726], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58755,8 +60739,8 @@ fn aiur_fn_700( 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_700] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_726] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58788,28 +60772,28 @@ fn aiur_fn_700( 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_700] = { let __args: [G; IN_700] = [__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[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = G::from_u64(0); let __v_39: G = { let __values: [G; 19] = [__v_38, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_36]; let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_700] = [__v_39, __v_37]; - if let Some(result) = record.function_queries[700].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_726] = [__v_39, __v_37]; + if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_701: usize = 2; -const IN_701: usize = 2; -const OUT_701: usize = 3; -fn aiur_fn_701( - inp: [G; IN_701], +const INPUT_SIZE_727: usize = 2; +const IN_727: usize = 2; +const OUT_727: usize = 3; +fn aiur_fn_727( + inp: [G; IN_727], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_701], ExecError> { +) -> Result<[G; OUT_727], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -58817,8 +60801,8 @@ fn aiur_fn_701( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_701] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_727] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -58832,27 +60816,27 @@ fn aiur_fn_701( 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_700] = { let __args: [G; IN_700] = [__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[700].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_700(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_701] = [__v_13, __v_11, __v_12]; - if let Some(result) = record.function_queries[701].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_727] = [__v_13, __v_11, __v_12]; + if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_702: usize = 1; -const IN_702: usize = 1; -const OUT_702: usize = 41; -fn aiur_fn_702( - inp: [G; IN_702], +const INPUT_SIZE_728: usize = 1; +const IN_728: usize = 1; +const OUT_728: usize = 41; +fn aiur_fn_728( + inp: [G; IN_728], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_702], ExecError> { +) -> Result<[G; OUT_728], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; @@ -58874,11 +60858,11 @@ fn aiur_fn_702( 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_697] = { let __args: [G; IN_697] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; let __v_20: G = __r_arr[2]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; @@ -58889,7 +60873,7 @@ fn aiur_fn_702( 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_695] = { let __args: [G; IN_695] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -58900,7 +60884,7 @@ fn aiur_fn_702( 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_695] = { let __args: [G; IN_695] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -58911,7 +60895,7 @@ fn aiur_fn_702( 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_695] = { let __args: [G; IN_695] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -58922,25 +60906,25 @@ fn aiur_fn_702( 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_696] = { let __args: [G; IN_696] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __ret: [G; OUT_702] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; - if let Some(result) = record.function_queries[702].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_728] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; + if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_703: usize = 1; -const IN_703: usize = 1; -const OUT_703: usize = 49; -fn aiur_fn_703( - inp: [G; IN_703], +const INPUT_SIZE_729: usize = 1; +const IN_729: usize = 1; +const OUT_729: usize = 49; +fn aiur_fn_729( + inp: [G; IN_729], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_703], ExecError> { +) -> Result<[G; OUT_729], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; @@ -58953,7 +60937,7 @@ fn aiur_fn_703( 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_702] = { let __args: [G; IN_702] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_702(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_728(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -58995,21 +60979,21 @@ fn aiur_fn_703( 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_703] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; - if let Some(result) = record.function_queries[703].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_729] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; + if let Some(result) = record.function_queries[729].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_704: usize = 9; -const IN_704: usize = 9; -const OUT_704: usize = 2; -fn aiur_fn_704( - inp: [G; IN_704], +const INPUT_SIZE_730: usize = 9; +const IN_730: usize = 9; +const OUT_730: usize = 2; +fn aiur_fn_730( + inp: [G; IN_730], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_704], ExecError> { +) -> Result<[G; OUT_730], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59027,12 +61011,12 @@ fn aiur_fn_704( 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_704] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_730] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_703(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[729].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_729(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_729] = unsafe { *(result.output.as_ptr() as *const [G; OUT_729]) }; __ret } } else { aiur_fn_729(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -59091,28 +61075,28 @@ fn aiur_fn_704( 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_704] = { let __args: [G; IN_704] = [__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[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; let __v_68: G = __r_arr[1]; let __v_69: G = G::from_u64(0); let __v_70: G = { let __values: [G; 50] = [__v_69, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_67]; let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_704] = [__v_70, __v_68]; - if let Some(result) = record.function_queries[704].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_730] = [__v_70, __v_68]; + if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_705: usize = 2; -const IN_705: usize = 2; -const OUT_705: usize = 3; -fn aiur_fn_705( - inp: [G; IN_705], +const INPUT_SIZE_731: usize = 2; +const IN_731: usize = 2; +const OUT_731: usize = 3; +fn aiur_fn_731( + inp: [G; IN_731], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_705], ExecError> { +) -> Result<[G; OUT_731], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59120,8 +61104,8 @@ fn aiur_fn_705( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __ret: [G; OUT_705] = [__v_2, __v_3, __v_1]; - if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_2, __v_3, __v_1]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59135,27 +61119,27 @@ fn aiur_fn_705( 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_704] = { let __args: [G; IN_704] = [__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[704].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_704(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_730(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = G::from_u64(0); - let __ret: [G; OUT_705] = [__v_13, __v_11, __v_12]; - if let Some(result) = record.function_queries[705].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_731] = [__v_13, __v_11, __v_12]; + if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_706: usize = 1; -const IN_706: usize = 1; -const OUT_706: usize = 55; -fn aiur_fn_706( - inp: [G; IN_706], +const INPUT_SIZE_732: usize = 1; +const IN_732: usize = 1; +const OUT_732: usize = 55; +fn aiur_fn_732( + inp: [G; IN_732], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_706], ExecError> { +) -> Result<[G; OUT_732], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -59191,15 +61175,15 @@ fn aiur_fn_706( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -59210,26 +61194,26 @@ fn aiur_fn_706( 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_696] = { let __args: [G; IN_696] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_706] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_732] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -59240,7 +61224,7 @@ fn aiur_fn_706( 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_695] = { let __args: [G; IN_695] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; @@ -59251,7 +61235,7 @@ fn aiur_fn_706( 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_695] = { let __args: [G; IN_695] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; let __v_53: G = __r_arr[2]; @@ -59262,30 +61246,30 @@ fn aiur_fn_706( 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_696] = { let __args: [G; IN_696] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; - let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[705].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_705(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_705] = unsafe { *(result.output.as_ptr() as *const [G; OUT_705]) }; __ret } } else { aiur_fn_705(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; let __v_67: G = G::from_u64(1); let __v_68: G = G::from_u64(0); - let __ret: [G; OUT_706] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; - if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_732] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66]; + if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -59296,7 +61280,7 @@ fn aiur_fn_706( 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_695] = { let __args: [G; IN_695] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -59307,7 +61291,7 @@ fn aiur_fn_706( 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_695] = { let __args: [G; IN_695] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -59318,7 +61302,7 @@ fn aiur_fn_706( 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_695] = { let __args: [G; IN_695] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -59329,7 +61313,7 @@ fn aiur_fn_706( 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_695] = { let __args: [G; IN_695] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -59340,17 +61324,17 @@ fn aiur_fn_706( 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_696] = { let __args: [G; IN_696] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(2); - let __ret: [G; OUT_706] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - if let Some(result) = record.function_queries[706].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_732] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59360,15 +61344,15 @@ fn aiur_fn_706( }) } -const INPUT_SIZE_707: usize = 1; -const IN_707: usize = 1; -const OUT_707: usize = 63; -fn aiur_fn_707( - inp: [G; IN_707], +const INPUT_SIZE_733: usize = 1; +const IN_733: usize = 1; +const OUT_733: usize = 63; +fn aiur_fn_733( + inp: [G; IN_733], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_707], ExecError> { +) -> Result<[G; OUT_733], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_74(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; @@ -59381,7 +61365,7 @@ fn aiur_fn_707( 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_706] = { let __args: [G; IN_706] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -59437,21 +61421,21 @@ fn aiur_fn_707( 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_707] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; - if let Some(result) = record.function_queries[707].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_733] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; + if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_708: usize = 9; -const IN_708: usize = 9; -const OUT_708: usize = 2; -fn aiur_fn_708( - inp: [G; IN_708], +const INPUT_SIZE_734: usize = 9; +const IN_734: usize = 9; +const OUT_734: usize = 2; +fn aiur_fn_734( + inp: [G; IN_734], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_708], ExecError> { +) -> Result<[G; OUT_734], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -59469,12 +61453,12 @@ fn aiur_fn_708( 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_708] = [__v_12, __v_0]; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_734] = [__v_12, __v_0]; + if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_707(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __v_12: G = __r_arr[2]; @@ -59547,28 +61531,28 @@ fn aiur_fn_708( 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_708] = { let __args: [G; IN_708] = [__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[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; let __v_82: G = __r_arr[1]; let __v_83: G = G::from_u64(0); let __v_84: G = { let __values: [G; 64] = [__v_83, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_81]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_708] = [__v_84, __v_82]; - if let Some(result) = record.function_queries[708].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_734] = [__v_84, __v_82]; + if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_709: usize = 1; -const IN_709: usize = 1; -const OUT_709: usize = 55; -fn aiur_fn_709( - inp: [G; IN_709], +const INPUT_SIZE_735: usize = 1; +const IN_735: usize = 1; +const OUT_735: usize = 55; +fn aiur_fn_735( + inp: [G; IN_735], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_709], ExecError> { +) -> Result<[G; OUT_735], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_72(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; @@ -59604,15 +61588,15 @@ fn aiur_fn_709( let __v_27: G = __b1_out[7]; match __v_1.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_698(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -59623,30 +61607,30 @@ fn aiur_fn_709( 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_696] = { let __args: [G; IN_696] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; let __v_49: G = __r_arr[2]; let __v_50: G = G::from_u64(0); let __v_51: G = G::from_u64(0); - let __ret: [G; OUT_709] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; let __v_35: G = __r_arr[1]; let __v_36: G = __r_arr[2]; @@ -59657,7 +61641,7 @@ fn aiur_fn_709( 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_695] = { let __args: [G; IN_695] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __v_45: G = __r_arr[1]; let __v_46: G = __r_arr[2]; @@ -59668,7 +61652,7 @@ fn aiur_fn_709( 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_695] = { let __args: [G; IN_695] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -59679,7 +61663,7 @@ fn aiur_fn_709( 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_695] = { let __args: [G; IN_695] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; let __v_66: G = __r_arr[2]; @@ -59690,7 +61674,7 @@ fn aiur_fn_709( 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_695] = { let __args: [G; IN_695] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -59701,25 +61685,25 @@ fn aiur_fn_709( 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_696] = { let __args: [G; IN_696] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; let __v_85: G = __r_arr[1]; let __v_86: G = __r_arr[2]; - let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_701(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; let __v_87: G = __r_arr[0]; let __v_88: G = __r_arr[1]; let __v_89: G = __r_arr[2]; let __v_90: G = G::from_u64(1); - let __ret: [G; OUT_709] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_697(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -59730,22 +61714,22 @@ fn aiur_fn_709( 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_696] = { let __args: [G; IN_696] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(2); let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_709] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_699(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_725(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = __r_arr[1]; let __v_33: G = __r_arr[2]; @@ -59756,18 +61740,18 @@ fn aiur_fn_709( 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_696] = { let __args: [G; IN_696] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; let __v_43: G = __r_arr[2]; let __v_44: G = G::from_u64(3); let __v_45: G = G::from_u64(0); - let __ret: [G; OUT_709] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -59778,7 +61762,7 @@ fn aiur_fn_709( 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_695] = { let __args: [G; IN_695] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; @@ -59789,18 +61773,18 @@ fn aiur_fn_709( let __v_45: G = __r_arr[7]; let __v_46: G = __r_arr[8]; let __v_47: G = __r_arr[9]; - let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; let __v_51: G = G::from_u64(4); let __v_52: G = G::from_u64(0); - let __ret: [G; OUT_709] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 5u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -59811,18 +61795,18 @@ fn aiur_fn_709( 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_696] = { let __args: [G; IN_696] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(5); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_709] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -59833,18 +61817,18 @@ fn aiur_fn_709( 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_696] = { let __args: [G; IN_696] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(6); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_709] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_695(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -59855,14 +61839,14 @@ fn aiur_fn_709( 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_696] = { let __args: [G; IN_696] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_696(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = __r_arr[2]; let __v_41: G = G::from_u64(7); let __v_42: G = G::from_u64(0); - let __ret: [G; OUT_709] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 8u64 => { @@ -59884,7 +61868,7 @@ fn aiur_fn_709( 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_708] = { let __args: [G; IN_708] = [__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[708].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_708(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; break '__mc_0 [__v_37, __v_38]; @@ -59898,8 +61882,8 @@ fn aiur_fn_709( 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_709] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; - if let Some(result) = record.function_queries[709].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_735] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; + if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59909,15 +61893,15 @@ fn aiur_fn_709( }) } -const INPUT_SIZE_710: usize = 1; -const IN_710: usize = 1; -const OUT_710: usize = 1; -fn aiur_fn_710( - inp: [G; IN_710], +const INPUT_SIZE_736: usize = 1; +const IN_736: usize = 1; +const OUT_736: usize = 1; +fn aiur_fn_736( + inp: [G; IN_736], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_710], ExecError> { +) -> Result<[G; OUT_736], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; @@ -59946,40 +61930,40 @@ fn aiur_fn_710( let __v_22: G = __r_arr[0]; let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_21(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_710] = [__v_23]; - if let Some(result) = record.function_queries[710].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[710].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_736] = [__v_23]; + if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_711: usize = 1; -const IN_711: usize = 1; -const OUT_711: usize = 1; -fn aiur_fn_711( - inp: [G; IN_711], +const INPUT_SIZE_737: usize = 1; +const IN_737: usize = 1; +const OUT_737: usize = 1; +fn aiur_fn_737( + inp: [G; IN_737], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_711], ExecError> { +) -> Result<[G; OUT_737], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(0); - let __ret: [G; OUT_711] = [__v_1]; - if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_737] = [__v_1]; + if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_711] = [__v_1]; - if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_737] = [__v_1]; + if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_711] = [__v_1]; - if let Some(result) = record.function_queries[711].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_737] = [__v_1]; + if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -59989,35 +61973,35 @@ fn aiur_fn_711( }) } -const INPUT_SIZE_712: usize = 3; -const IN_712: usize = 3; -const OUT_712: usize = 0; -fn aiur_fn_712( - inp: [G; IN_712], +const INPUT_SIZE_738: usize = 3; +const IN_738: usize = 3; +const OUT_738: usize = 0; +fn aiur_fn_738( + inp: [G; IN_738], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_712], ExecError> { +) -> Result<[G; OUT_738], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_712] = []; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_738] = []; + if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition kind != real".to_string()) }); } - let __ret: [G; OUT_712] = []; - if let Some(result) = record.function_queries[712].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_738] = []; + if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60027,35 +62011,35 @@ fn aiur_fn_712( }) } -const INPUT_SIZE_713: usize = 3; -const IN_713: usize = 3; -const OUT_713: usize = 0; -fn aiur_fn_713( - inp: [G; IN_713], +const INPUT_SIZE_739: usize = 3; +const IN_739: usize = 3; +const OUT_739: usize = 0; +fn aiur_fn_739( + inp: [G; IN_739], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_713], ExecError> { +) -> Result<[G; OUT_739], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_713] = []; - if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_739] = []; + if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_711(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition safety != real".to_string()) }); } - let __ret: [G; OUT_713] = []; - if let Some(result) = record.function_queries[713].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_739] = []; + if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60065,23 +62049,23 @@ fn aiur_fn_713( }) } -const INPUT_SIZE_714: usize = 3; -const IN_714: usize = 3; -const OUT_714: usize = 0; -fn aiur_fn_714( - inp: [G; IN_714], +const INPUT_SIZE_740: usize = 3; +const IN_740: usize = 3; +const OUT_740: usize = 0; +fn aiur_fn_740( + inp: [G; IN_740], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_714], ExecError> { +) -> Result<[G; OUT_740], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_714] = []; - if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_740] = []; + if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -60092,8 +62076,8 @@ fn aiur_fn_714( if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed quotient kind != real".to_string()) }); } - let __ret: [G; OUT_714] = []; - if let Some(result) = record.function_queries[714].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_740] = []; + if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60103,31 +62087,31 @@ fn aiur_fn_714( }) } -const INPUT_SIZE_715: usize = 3; -const IN_715: usize = 3; -const OUT_715: usize = 0; -fn aiur_fn_715( - inp: [G; IN_715], +const INPUT_SIZE_741: usize = 3; +const IN_741: usize = 3; +const OUT_741: usize = 0; +fn aiur_fn_741( + inp: [G; IN_741], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_715], ExecError> { +) -> Result<[G; OUT_741], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_715] = []; - if let Some(result) = record.function_queries[715].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_741] = []; + if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { if (__v_0 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed flag != real".to_string()) }); } - let __ret: [G; OUT_715] = []; - if let Some(result) = record.function_queries[715].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_741] = []; + if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60137,15 +62121,15 @@ fn aiur_fn_715( }) } -const INPUT_SIZE_716: usize = 17; -const IN_716: usize = 17; -const OUT_716: usize = 0; -fn aiur_fn_716( - inp: [G; IN_716], +const INPUT_SIZE_742: usize = 17; +const IN_742: usize = 17; +const OUT_742: usize = 0; +fn aiur_fn_742( + inp: [G; IN_742], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_716], ExecError> { +) -> Result<[G; OUT_742], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60166,8 +62150,8 @@ fn aiur_fn_716( let __v_16: G = inp[16]; match __v_8.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_716] = []; - if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_742] = []; + if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -60195,8 +62179,8 @@ fn aiur_fn_716( if (__v_7 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) }); } - let __ret: [G; OUT_716] = []; - if let Some(result) = record.function_queries[716].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_742] = []; + if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60206,23 +62190,23 @@ fn aiur_fn_716( }) } -const INPUT_SIZE_717: usize = 3; -const IN_717: usize = 3; -const OUT_717: usize = 0; -fn aiur_fn_717( - inp: [G; IN_717], +const INPUT_SIZE_743: usize = 3; +const IN_743: usize = 3; +const OUT_743: usize = 0; +fn aiur_fn_743( + inp: [G; IN_743], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_717], ExecError> { +) -> Result<[G; OUT_743], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_717] = []; - if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_743] = []; + if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -60388,8 +62372,8 @@ fn aiur_fn_717( if (__v_34 != __v_66) { return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64(), msg: Some("Reveal: claimed address field != real".to_string()) }); } - let __ret: [G; OUT_717] = []; - if let Some(result) = record.function_queries[717].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_743] = []; + if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60399,27 +62383,27 @@ fn aiur_fn_717( }) } -const INPUT_SIZE_718: usize = 3; -const IN_718: usize = 3; -const OUT_718: usize = 0; -fn aiur_fn_718( - inp: [G; IN_718], +const INPUT_SIZE_744: usize = 3; +const IN_744: usize = 3; +const OUT_744: usize = 0; +fn aiur_fn_744( + inp: [G; IN_744], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_718], ExecError> { +) -> Result<[G; OUT_744], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_718] = []; - if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_744] = []; + if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_710(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_736(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -60583,8 +62567,8 @@ fn aiur_fn_718( if (__v_35 != __v_67) { return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64(), msg: Some("Reveal: claimed expr hash != hash of the real expr".to_string()) }); } - let __ret: [G; OUT_718] = []; - if let Some(result) = record.function_queries[718].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_744] = []; + if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60594,15 +62578,15 @@ fn aiur_fn_718( }) } -const INPUT_SIZE_719: usize = 10; -const IN_719: usize = 10; -const OUT_719: usize = 0; -fn aiur_fn_719( - inp: [G; IN_719], +const INPUT_SIZE_745: usize = 10; +const IN_745: usize = 10; +const OUT_745: usize = 0; +fn aiur_fn_745( + inp: [G; IN_745], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_719], ExecError> { +) -> Result<[G; OUT_745], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60650,8 +62634,8 @@ fn aiur_fn_719( let __v_39: G = __loaded[10]; match __v_29.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_719] = []; - if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_745] = []; + if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60679,7 +62663,7 @@ fn aiur_fn_719( match __v_30.as_canonical_u64() { _ => { let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; if (__v_11 != __v_2) { return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule index != its position".to_string()) }); } @@ -60737,9 +62721,9 @@ fn aiur_fn_719( let __v_46: G = __r_arr[5]; let __v_47: G = __r_arr[6]; let __v_48: G = __r_arr[7]; - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_719] = []; - if let Some(result) = record.function_queries[719].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_745] = []; + if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -60758,23 +62742,23 @@ fn aiur_fn_719( }) } -const INPUT_SIZE_720: usize = 3; -const IN_720: usize = 3; -const OUT_720: usize = 0; -fn aiur_fn_720( - inp: [G; IN_720], +const INPUT_SIZE_746: usize = 3; +const IN_746: usize = 3; +const OUT_746: usize = 0; +fn aiur_fn_746( + inp: [G; IN_746], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_720], ExecError> { +) -> Result<[G; OUT_746], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_720] = []; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_746] = []; + if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -60786,9 +62770,9 @@ fn aiur_fn_720( let __v_8: G = G::from_u64(0); let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_720] = []; - if let Some(result) = record.function_queries[720].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_746] = []; + if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60798,15 +62782,15 @@ fn aiur_fn_720( }) } -const INPUT_SIZE_721: usize = 49; -const IN_721: usize = 49; -const OUT_721: usize = 0; -fn aiur_fn_721( - inp: [G; IN_721], +const INPUT_SIZE_747: usize = 49; +const IN_747: usize = 49; +const OUT_747: usize = 0; +fn aiur_fn_747( + inp: [G; IN_747], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_721], ExecError> { +) -> Result<[G; OUT_747], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60857,7 +62841,7 @@ fn aiur_fn_721( let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; - let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__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[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; let __v_51: G = __r_arr[2]; @@ -60896,14 +62880,14 @@ fn aiur_fn_721( _ => { match __v_49.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_721] = []; - if let Some(result) = record.function_queries[721].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_747] = []; + if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -60912,15 +62896,15 @@ fn aiur_fn_721( }) } -const INPUT_SIZE_722: usize = 2; -const IN_722: usize = 2; -const OUT_722: usize = 0; -fn aiur_fn_722( - inp: [G; IN_722], +const INPUT_SIZE_748: usize = 2; +const IN_748: usize = 2; +const OUT_748: usize = 0; +fn aiur_fn_748( + inp: [G; IN_748], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_722], ExecError> { +) -> Result<[G; OUT_748], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -60977,15 +62961,15 @@ fn aiur_fn_722( let __v_51: G = __loaded[49]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_722] = []; - if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__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[721].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_721(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_722] = []; - if let Some(result) = record.function_queries[722].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_748] = []; + if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -60995,29 +62979,29 @@ fn aiur_fn_722( }) } -const INPUT_SIZE_723: usize = 3; -const IN_723: usize = 3; -const OUT_723: usize = 0; -fn aiur_fn_723( - inp: [G; IN_723], +const INPUT_SIZE_749: usize = 3; +const IN_749: usize = 3; +const OUT_749: usize = 0; +fn aiur_fn_749( + inp: [G; IN_749], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_723], ExecError> { +) -> Result<[G; OUT_749], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_723] = []; - if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_749] = []; + if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_722(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_723] = []; - if let Some(result) = record.function_queries[723].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_749] = []; + if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61027,15 +63011,15 @@ fn aiur_fn_723( }) } -const INPUT_SIZE_724: usize = 99; -const IN_724: usize = 99; -const OUT_724: usize = 0; -fn aiur_fn_724( - inp: [G; IN_724], +const INPUT_SIZE_750: usize = 99; +const IN_750: usize = 99; +const OUT_750: usize = 0; +fn aiur_fn_750( + inp: [G; IN_750], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_724], ExecError> { +) -> Result<[G; OUT_750], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -61142,13 +63126,13 @@ fn aiur_fn_724( 0u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_724] = []; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -61163,14 +63147,14 @@ fn aiur_fn_724( 1u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[723].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_723(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_724] = []; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -61185,17 +63169,17 @@ fn aiur_fn_724( 2u64 => { match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_724] = []; - if let Some(result) = record.function_queries[724].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_750] = []; + if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -61212,15 +63196,15 @@ fn aiur_fn_724( }) } -const INPUT_SIZE_725: usize = 2; -const IN_725: usize = 2; -const OUT_725: usize = 0; -fn aiur_fn_725( - inp: [G; IN_725], +const INPUT_SIZE_751: usize = 2; +const IN_751: usize = 2; +const OUT_751: usize = 0; +fn aiur_fn_751( + inp: [G; IN_751], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_725], ExecError> { +) -> Result<[G; OUT_751], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -61291,12 +63275,12 @@ fn aiur_fn_725( let __v_65: G = __loaded[63]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_725] = []; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_751] = []; + if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__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[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; let __v_67: G = __r_arr[1]; let __v_68: G = __r_arr[2]; @@ -61342,10 +63326,10 @@ fn aiur_fn_725( 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_724] = { let __args: [G; IN_724] = [__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[724].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_724(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_725(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_725] = []; - if let Some(result) = record.function_queries[725].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_750(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[751].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_751(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_751] = unsafe { *(result.output.as_ptr() as *const [G; OUT_751]) }; __ret } } else { aiur_fn_751(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_751] = []; + if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61355,15 +63339,15 @@ fn aiur_fn_725( }) } -const INPUT_SIZE_726: usize = 55; -const IN_726: usize = 55; -const OUT_726: usize = 0; -fn aiur_fn_726( - inp: [G; IN_726], +const INPUT_SIZE_752: usize = 55; +const IN_752: usize = 55; +const OUT_752: usize = 0; +fn aiur_fn_752( + inp: [G; IN_752], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_726], ExecError> { +) -> Result<[G; OUT_752], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -61420,7 +63404,7 @@ fn aiur_fn_726( let __v_52: G = inp[52]; let __v_53: G = inp[53]; let __v_54: G = inp[54]; - let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_260(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_260] = unsafe { *(result.output.as_ptr() as *const [G; OUT_260]) }; __ret } } else { aiur_fn_260(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_282(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; let __v_56: G = __r_arr[1]; let __v_57: G = __r_arr[2]; @@ -61477,13 +63461,13 @@ fn aiur_fn_726( 0u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_712(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_726] = []; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -61498,17 +63482,17 @@ fn aiur_fn_726( 1u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_726] = []; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[746].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_746(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_746] = unsafe { *(result.output.as_ptr() as *const [G; OUT_746]) }; __ret } } else { aiur_fn_746(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -61523,11 +63507,11 @@ fn aiur_fn_726( 2u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_715(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_726] = []; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -61542,11 +63526,11 @@ fn aiur_fn_726( 3u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_718(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_726] = []; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[740].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_740(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -61561,11 +63545,11 @@ fn aiur_fn_726( 4u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_726] = []; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -61580,10 +63564,10 @@ fn aiur_fn_726( 5u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_726] = []; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -61598,10 +63582,10 @@ fn aiur_fn_726( 6u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_726] = []; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -61616,10 +63600,10 @@ fn aiur_fn_726( 7u64 => { match __v_56.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__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[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; - let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_717(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_726] = []; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -61632,9 +63616,9 @@ fn aiur_fn_726( 8u64 => { match __v_1.as_canonical_u64() { 8u64 => { - let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_725(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_726] = []; - if let Some(result) = record.function_queries[726].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[751].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_751(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_751] = unsafe { *(result.output.as_ptr() as *const [G; OUT_751]) }; __ret } } else { aiur_fn_751(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_752] = []; + if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61651,41 +63635,41 @@ fn aiur_fn_726( }) } -const INPUT_SIZE_727: usize = 2; -const IN_727: usize = 2; -const OUT_727: usize = 0; -fn aiur_fn_727( - inp: [G; IN_727], +const INPUT_SIZE_753: usize = 2; +const IN_753: usize = 2; +const OUT_753: usize = 0; +fn aiur_fn_753( + inp: [G; IN_753], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_727], ExecError> { +) -> Result<[G; OUT_753], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; - let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_392(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_417(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); if (__v_3 != __v_4) { return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Contains: target is not a leaf of the claimed tree".to_string()) }); } - let __ret: [G; OUT_727] = []; - if let Some(result) = record.function_queries[727].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_753] = []; + if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_728: usize = 8; -const IN_728: usize = 8; -const OUT_728: usize = 0; -fn aiur_fn_728( - inp: [G; IN_728], +const INPUT_SIZE_754: usize = 8; +const IN_754: usize = 8; +const OUT_754: usize = 0; +fn aiur_fn_754( + inp: [G; IN_754], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_728], ExecError> { +) -> Result<[G; OUT_754], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -61913,23 +63897,23 @@ fn aiur_fn_728( let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; match __v_188.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_186]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_680(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_728] = []; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_186]; let __cu = unconstrained; if let Some(result) = record.function_queries[706].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_706(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_706] = unsafe { *(result.output.as_ptr() as *const [G; OUT_706]) }; __ret } } else { aiur_fn_706(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_754] = []; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_687(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_713(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; let __v_191: G = __r_arr[0]; let __v_192: G = G::from_u64(1); let __v_193: G = G::from_u64(1); - let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[688].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_688(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_714(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; let __v_194: G = __r_arr[0]; let __v_195: G = __r_arr[1]; let __v_196: G = __r_arr[2]; @@ -61939,9 +63923,9 @@ fn aiur_fn_728( let __v_200: G = G::from_u64(1); let __v_201: G = G::from_u64(1); let __v_202: G = G::from_u64(0); - let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_690(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_728] = []; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_716(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_754] = []; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -61953,20 +63937,20 @@ fn aiur_fn_728( let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_694(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_720(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; - let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_693(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_728] = []; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_719(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_754] = []; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 6u64 => { let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_186: G = __r_arr[0]; let __v_187: G = __r_arr[1]; - let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[709].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_709(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_709] = unsafe { *(result.output.as_ptr() as *const [G; OUT_709]) }; __ret } } else { aiur_fn_709(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; let __v_190: G = __r_arr[2]; @@ -62022,9 +64006,9 @@ fn aiur_fn_728( let __v_240: G = __r_arr[52]; let __v_241: G = __r_arr[53]; let __v_242: G = __r_arr[54]; - let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_726(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_728] = []; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241]; let __cu = unconstrained; if let Some(result) = record.function_queries[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_754] = []; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 7u64 => { @@ -62034,9 +64018,9 @@ fn aiur_fn_728( let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_187]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_85(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; let __v_188: G = __r_arr[0]; let __v_189: G = __r_arr[1]; - let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_727(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_728] = []; - if let Some(result) = record.function_queries[728].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_186, __v_188]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_754] = []; + if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62046,15 +64030,15 @@ fn aiur_fn_728( }) } -const INPUT_SIZE_729: usize = 8; -const IN_729: usize = 8; -const OUT_729: usize = 0; -fn aiur_fn_729( - inp: [G; IN_729], +const INPUT_SIZE_755: usize = 8; +const IN_755: usize = 8; +const OUT_755: usize = 0; +fn aiur_fn_755( + inp: [G; IN_755], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_729], ExecError> { +) -> Result<[G; OUT_755], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62064,27 +64048,27 @@ fn aiur_fn_729( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - 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]; let __cu = unconstrained; if let Some(result) = record.function_queries[728].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_728(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; - let __ret: [G; OUT_729] = []; - if let Some(result) = record.function_queries[729].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_755] = []; + if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_730: usize = 3; -const IN_730: usize = 3; -const OUT_730: usize = 1; -fn aiur_fn_730( - inp: [G; IN_730], +const INPUT_SIZE_756: usize = 3; +const IN_756: usize = 3; +const OUT_756: usize = 1; +fn aiur_fn_756( + inp: [G; IN_756], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_730], ExecError> { +) -> Result<[G; OUT_756], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_4: G = __loaded[0]; @@ -62092,13 +64076,13 @@ fn aiur_fn_730( let __v_6: G = __loaded[2]; match __v_4.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_730] = [__v_2]; - if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_756] = [__v_2]; + if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __ret: [G; OUT_730] = [__v_5]; - if let Some(result) = record.function_queries[730].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_756] = [__v_5]; + if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62108,15 +64092,15 @@ fn aiur_fn_730( }) } -const INPUT_SIZE_731: usize = 2; -const IN_731: usize = 2; -const OUT_731: usize = 1; -fn aiur_fn_731( - inp: [G; IN_731], +const INPUT_SIZE_757: usize = 2; +const IN_757: usize = 2; +const OUT_757: usize = 1; +fn aiur_fn_757( + inp: [G; IN_757], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_731], ExecError> { +) -> Result<[G; OUT_757], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62131,17 +64115,17 @@ fn aiur_fn_731( 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_731] = [__v_9]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_9]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_731(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_731] = [__v_7]; - if let Some(result) = record.function_queries[731].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_757] = [__v_7]; + if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62151,15 +64135,15 @@ fn aiur_fn_731( }) } -const INPUT_SIZE_732: usize = 1; -const IN_732: usize = 1; -const OUT_732: usize = 8; -fn aiur_fn_732( - inp: [G; IN_732], +const INPUT_SIZE_758: usize = 1; +const IN_758: usize = 1; +const OUT_758: usize = 8; +fn aiur_fn_758( + inp: [G; IN_758], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_732], ExecError> { +) -> Result<[G; OUT_758], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -62183,12 +64167,12 @@ fn aiur_fn_732( 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_732] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; - if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_758] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_732(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[758].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_758(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_758] = unsafe { *(result.output.as_ptr() as *const [G; OUT_758]) }; __ret } } else { aiur_fn_758(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -62206,8 +64190,8 @@ fn aiur_fn_732( 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_732] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - if let Some(result) = record.function_queries[732].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_758] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + if let Some(result) = record.function_queries[758].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[758].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62217,15 +64201,15 @@ fn aiur_fn_732( }) } -const INPUT_SIZE_733: usize = 2; -const IN_733: usize = 2; -const OUT_733: usize = 1; -fn aiur_fn_733( - inp: [G; IN_733], +const INPUT_SIZE_759: usize = 2; +const IN_759: usize = 2; +const OUT_759: usize = 1; +fn aiur_fn_759( + inp: [G; IN_759], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_733], ExecError> { +) -> Result<[G; OUT_759], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62236,17 +64220,17 @@ fn aiur_fn_733( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_733] = [__v_1]; - if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_759] = [__v_1]; + if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_6: G = G::from_u64(0); - let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_733(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[759].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_759(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_759] = unsafe { *(result.output.as_ptr() as *const [G; OUT_759]) }; __ret } } else { aiur_fn_759(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_733] = [__v_8]; - if let Some(result) = record.function_queries[733].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_759] = [__v_8]; + if let Some(result) = record.function_queries[759].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[759].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62256,15 +64240,15 @@ fn aiur_fn_733( }) } -const INPUT_SIZE_734: usize = 1; -const IN_734: usize = 1; -const OUT_734: usize = 8; -fn aiur_fn_734( - inp: [G; IN_734], +const INPUT_SIZE_760: usize = 1; +const IN_760: usize = 1; +const OUT_760: usize = 8; +fn aiur_fn_760( + inp: [G; IN_760], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_734], ExecError> { +) -> Result<[G; OUT_760], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -62281,12 +64265,12 @@ fn aiur_fn_734( 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_734] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_760] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_734(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[760].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_760(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_760] = unsafe { *(result.output.as_ptr() as *const [G; OUT_760]) }; __ret } } else { aiur_fn_760(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -62304,8 +64288,8 @@ fn aiur_fn_734( 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_734] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[734].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_760] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[760].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[760].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62315,15 +64299,15 @@ fn aiur_fn_734( }) } -const INPUT_SIZE_735: usize = 8; -const IN_735: usize = 8; -const OUT_735: usize = 1; -fn aiur_fn_735( - inp: [G; IN_735], +const INPUT_SIZE_761: usize = 8; +const IN_761: usize = 8; +const OUT_761: usize = 1; +fn aiur_fn_761( + inp: [G; IN_761], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_735], ExecError> { +) -> Result<[G; OUT_761], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62335,8 +64319,8 @@ fn aiur_fn_735( let __v_7: G = inp[7]; match __v_1.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_735] = [__v_7]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_7]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -62357,25 +64341,25 @@ fn aiur_fn_735( 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_735] = { let __args: [G; IN_735] = [__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[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_735] = [__v_21]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_21]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_21: G = (__v_0 - __v_3); match __v_21.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_735] = [__v_4]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_4]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__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[735].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_735(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[761].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_761(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_761] = unsafe { *(result.output.as_ptr() as *const [G; OUT_761]) }; __ret } } else { aiur_fn_761(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; - let __ret: [G; OUT_735] = [__v_22]; - if let Some(result) = record.function_queries[735].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_761] = [__v_22]; + if let Some(result) = record.function_queries[761].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[761].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -62389,37 +64373,37 @@ fn aiur_fn_735( }) } -const INPUT_SIZE_736: usize = 1; -const IN_736: usize = 1; -const OUT_736: usize = 1; -fn aiur_fn_736( - inp: [G; IN_736], +const INPUT_SIZE_762: usize = 1; +const IN_762: usize = 1; +const OUT_762: usize = 1; +fn aiur_fn_762( + inp: [G; IN_762], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_736], ExecError> { +) -> Result<[G; OUT_762], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(1); let __v_2: G = G::from_u64(1); let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_780(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } } else { aiur_fn_780(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; - let __ret: [G; OUT_736] = [__v_4]; - if let Some(result) = record.function_queries[736].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_762] = [__v_4]; + if let Some(result) = record.function_queries[762].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[762].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }) } -const INPUT_SIZE_737: usize = 2; -const IN_737: usize = 2; -const OUT_737: usize = 1; -fn aiur_fn_737( - inp: [G; IN_737], +const INPUT_SIZE_763: usize = 2; +const IN_763: usize = 2; +const OUT_763: usize = 1; +fn aiur_fn_763( + inp: [G; IN_763], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_737], ExecError> { +) -> Result<[G; OUT_763], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62429,17 +64413,17 @@ fn aiur_fn_737( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_737] = [__v_1]; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_763] = [__v_1]; + if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[737].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_737(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[763].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_763(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_763] = unsafe { *(result.output.as_ptr() as *const [G; OUT_763]) }; __ret } } else { aiur_fn_763(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_737] = [__v_7]; - if let Some(result) = record.function_queries[737].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_763] = [__v_7]; + if let Some(result) = record.function_queries[763].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[763].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62449,15 +64433,15 @@ fn aiur_fn_737( }) } -const INPUT_SIZE_738: usize = 1; -const IN_738: usize = 1; -const OUT_738: usize = 1; -fn aiur_fn_738( - inp: [G; IN_738], +const INPUT_SIZE_764: usize = 1; +const IN_764: usize = 1; +const OUT_764: usize = 1; +fn aiur_fn_764( + inp: [G; IN_764], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_738], ExecError> { +) -> Result<[G; OUT_764], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -62467,17 +64451,17 @@ fn aiur_fn_738( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_738] = [__v_4]; - if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_764] = [__v_4]; + if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_738(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[764].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_764(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_764] = unsafe { *(result.output.as_ptr() as *const [G; OUT_764]) }; __ret } } else { aiur_fn_764(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_4 + __v_5); - let __ret: [G; OUT_738] = [__v_6]; - if let Some(result) = record.function_queries[738].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_764] = [__v_6]; + if let Some(result) = record.function_queries[764].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[764].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62487,15 +64471,15 @@ fn aiur_fn_738( }) } -const INPUT_SIZE_739: usize = 1; -const IN_739: usize = 1; -const OUT_739: usize = 8; -fn aiur_fn_739( - inp: [G; IN_739], +const INPUT_SIZE_765: usize = 1; +const IN_765: usize = 1; +const OUT_765: usize = 8; +fn aiur_fn_765( + inp: [G; IN_765], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_739], ExecError> { +) -> Result<[G; OUT_765], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr }; @@ -62545,12 +64529,12 @@ fn aiur_fn_739( 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_739] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; - if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_765] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; + if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_739(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[765].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_765(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_765] = unsafe { *(result.output.as_ptr() as *const [G; OUT_765]) }; __ret } } else { aiur_fn_765(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; let __v_39: G = __r_arr[2]; @@ -62568,8 +64552,8 @@ fn aiur_fn_739( 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_739] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; - if let Some(result) = record.function_queries[739].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_765] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; + if let Some(result) = record.function_queries[765].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[765].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62579,19 +64563,19 @@ fn aiur_fn_739( }) } -const INPUT_SIZE_740: usize = 2; -const IN_740: usize = 2; -const OUT_740: usize = 1; -fn aiur_fn_740( - inp: [G; IN_740], +const INPUT_SIZE_766: usize = 2; +const IN_766: usize = 2; +const OUT_766: usize = 1; +fn aiur_fn_766( + inp: [G; IN_766], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_740], ExecError> { +) -> Result<[G; OUT_766], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -62599,8 +64583,8 @@ fn aiur_fn_740( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_740] = [__v_4]; - if let Some(result) = record.function_queries[740].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_766] = [__v_4]; + if let Some(result) = record.function_queries[766].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[766].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62610,15 +64594,15 @@ fn aiur_fn_740( }) } -const INPUT_SIZE_741: usize = 1; -const IN_741: usize = 1; -const OUT_741: usize = 1; -fn aiur_fn_741( - inp: [G; IN_741], +const INPUT_SIZE_767: usize = 1; +const IN_767: usize = 1; +const OUT_767: usize = 1; +fn aiur_fn_767( + inp: [G; IN_767], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_741], ExecError> { +) -> Result<[G; OUT_767], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; @@ -62635,17 +64619,17 @@ fn aiur_fn_741( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_741] = [__v_11]; - if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_767] = [__v_11]; + if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[741].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_741(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[767].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_767(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_767] = unsafe { *(result.output.as_ptr() as *const [G; OUT_767]) }; __ret } } else { aiur_fn_767(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_11 + __v_12); - let __ret: [G; OUT_741] = [__v_13]; - if let Some(result) = record.function_queries[741].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_767] = [__v_13]; + if let Some(result) = record.function_queries[767].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[767].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62655,15 +64639,15 @@ fn aiur_fn_741( }) } -const INPUT_SIZE_742: usize = 9; -const IN_742: usize = 9; -const OUT_742: usize = 45; -fn aiur_fn_742( - inp: [G; IN_742], +const INPUT_SIZE_768: usize = 9; +const IN_768: usize = 9; +const OUT_768: usize = 45; +fn aiur_fn_768( + inp: [G; IN_768], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_742], ExecError> { +) -> Result<[G; OUT_768], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -62728,8 +64712,8 @@ fn aiur_fn_742( let __v_56: G = __r_arr[0]; match __v_56.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_742] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; - if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_768] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; + if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -62742,7 +64726,7 @@ fn aiur_fn_742( 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_742] = { let __args: [G; IN_742] = [__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[742].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_742(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[768].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_768(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_768] = unsafe { *(result.output.as_ptr() as *const [G; OUT_768]) }; __ret } } else { aiur_fn_768(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -62788,8 +64772,8 @@ fn aiur_fn_742( 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_742] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; - if let Some(result) = record.function_queries[742].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_768] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; + if let Some(result) = record.function_queries[768].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[768].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62804,15 +64788,15 @@ fn aiur_fn_742( }) } -const INPUT_SIZE_743: usize = 1; -const IN_743: usize = 1; -const OUT_743: usize = 8; -fn aiur_fn_743( - inp: [G; IN_743], +const INPUT_SIZE_769: usize = 1; +const IN_769: usize = 1; +const OUT_769: usize = 8; +fn aiur_fn_769( + inp: [G; IN_769], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_743], ExecError> { +) -> Result<[G; OUT_769], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr }; @@ -62873,12 +64857,12 @@ fn aiur_fn_743( 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_743] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; - if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_769] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[743].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_743(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_743] = unsafe { *(result.output.as_ptr() as *const [G; OUT_743]) }; __ret } } else { aiur_fn_743(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[769].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_769(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_769] = unsafe { *(result.output.as_ptr() as *const [G; OUT_769]) }; __ret } } else { aiur_fn_769(__args, record, io_buffer, __cu)? } }; let __v_48: G = __r_arr[0]; let __v_49: G = __r_arr[1]; let __v_50: G = __r_arr[2]; @@ -62896,8 +64880,8 @@ fn aiur_fn_743( 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_743] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; - if let Some(result) = record.function_queries[743].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[743].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_769] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + if let Some(result) = record.function_queries[769].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[769].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62907,15 +64891,15 @@ fn aiur_fn_743( }) } -const INPUT_SIZE_744: usize = 1; -const IN_744: usize = 1; -const OUT_744: usize = 8; -fn aiur_fn_744( - inp: [G; IN_744], +const INPUT_SIZE_770: usize = 1; +const IN_770: usize = 1; +const OUT_770: usize = 8; +fn aiur_fn_770( + inp: [G; IN_770], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_744], ExecError> { +) -> Result<[G; OUT_770], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; @@ -62940,12 +64924,12 @@ fn aiur_fn_744( 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_744] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_770] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[744].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_744(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_744] = unsafe { *(result.output.as_ptr() as *const [G; OUT_744]) }; __ret } } else { aiur_fn_744(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[770].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_770(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_770] = unsafe { *(result.output.as_ptr() as *const [G; OUT_770]) }; __ret } } else { aiur_fn_770(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -62963,8 +64947,8 @@ fn aiur_fn_744( 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_744] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; - if let Some(result) = record.function_queries[744].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[744].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_770] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; + if let Some(result) = record.function_queries[770].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[770].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -62974,15 +64958,15 @@ fn aiur_fn_744( }) } -const INPUT_SIZE_745: usize = 9; -const IN_745: usize = 9; -const OUT_745: usize = 34; -fn aiur_fn_745( - inp: [G; IN_745], +const INPUT_SIZE_771: usize = 9; +const IN_771: usize = 9; +const OUT_771: usize = 34; +fn aiur_fn_771( + inp: [G; IN_771], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_745], ExecError> { +) -> Result<[G; OUT_771], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63036,8 +65020,8 @@ fn aiur_fn_745( let __v_45: G = __r_arr[0]; match __v_45.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_745] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; - if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_771] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; + if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -63050,7 +65034,7 @@ fn aiur_fn_745( 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_745] = { let __args: [G; IN_745] = [__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[745].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_745(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_745] = unsafe { *(result.output.as_ptr() as *const [G; OUT_745]) }; __ret } } else { aiur_fn_745(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[771].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_771(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_771] = unsafe { *(result.output.as_ptr() as *const [G; OUT_771]) }; __ret } } else { aiur_fn_771(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = __r_arr[1]; let __v_56: G = __r_arr[2]; @@ -63085,8 +65069,8 @@ fn aiur_fn_745( 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_745] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; - if let Some(result) = record.function_queries[745].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[745].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_771] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; + if let Some(result) = record.function_queries[771].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[771].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63101,15 +65085,15 @@ fn aiur_fn_745( }) } -const INPUT_SIZE_746: usize = 1; -const IN_746: usize = 1; -const OUT_746: usize = 1; -fn aiur_fn_746( - inp: [G; IN_746], +const INPUT_SIZE_772: usize = 1; +const IN_772: usize = 1; +const OUT_772: usize = 1; +fn aiur_fn_772( + inp: [G; IN_772], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_746], ExecError> { +) -> Result<[G; OUT_772], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -63119,14 +65103,14 @@ fn aiur_fn_746( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_746] = [__v_4]; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_772] = [__v_4]; + if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_746] = [__v_4]; - if let Some(result) = record.function_queries[746].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[746].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_772] = [__v_4]; + if let Some(result) = record.function_queries[772].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[772].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63136,15 +65120,15 @@ fn aiur_fn_746( }) } -const INPUT_SIZE_747: usize = 5; -const IN_747: usize = 5; -const OUT_747: usize = 1; -fn aiur_fn_747( - inp: [G; IN_747], +const INPUT_SIZE_773: usize = 5; +const IN_773: usize = 5; +const OUT_773: usize = 1; +fn aiur_fn_773( + inp: [G; IN_773], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_747], ExecError> { +) -> Result<[G; OUT_773], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63165,17 +65149,17 @@ fn aiur_fn_747( let __v_13: G = G::from_u64(1); let __v_14: G = { let __values: [G; 6] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_15: G = { let __values: [G; 6] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_747] = [__v_15]; - if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_773] = [__v_15]; + if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[747].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_747(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_747] = unsafe { *(result.output.as_ptr() as *const [G; OUT_747]) }; __ret } } else { aiur_fn_747(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[773].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_773(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_773] = unsafe { *(result.output.as_ptr() as *const [G; OUT_773]) }; __ret } } else { aiur_fn_773(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 6] = [__v_11, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_747] = [__v_13]; - if let Some(result) = record.function_queries[747].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[747].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_773] = [__v_13]; + if let Some(result) = record.function_queries[773].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[773].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63185,15 +65169,15 @@ fn aiur_fn_747( }) } -const INPUT_SIZE_748: usize = 2; -const IN_748: usize = 2; -const OUT_748: usize = 1; -fn aiur_fn_748( - inp: [G; IN_748], +const INPUT_SIZE_774: usize = 2; +const IN_774: usize = 2; +const OUT_774: usize = 1; +fn aiur_fn_774( + inp: [G; IN_774], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_748], ExecError> { +) -> Result<[G; OUT_774], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63202,8 +65186,8 @@ fn aiur_fn_748( 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_748] = [__v_4]; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_774] = [__v_4]; + if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63216,11 +65200,11 @@ fn aiur_fn_748( 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_748] = { let __args: [G; IN_748] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[748].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_748(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_748] = unsafe { *(result.output.as_ptr() as *const [G; OUT_748]) }; __ret } } else { aiur_fn_748(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[774].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_774(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_774] = unsafe { *(result.output.as_ptr() as *const [G; OUT_774]) }; __ret } } else { aiur_fn_774(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = { let __values: [G; 3] = [__v_5, __v_3, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_748] = [__v_9]; - if let Some(result) = record.function_queries[748].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[748].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_774] = [__v_9]; + if let Some(result) = record.function_queries[774].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[774].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63232,28 +65216,28 @@ fn aiur_fn_748( }) } -const INPUT_SIZE_749: usize = 2; -const IN_749: usize = 2; -const OUT_749: usize = 1; -fn aiur_fn_749( - inp: [G; IN_749], +const INPUT_SIZE_775: usize = 2; +const IN_775: usize = 2; +const OUT_775: usize = 1; +fn aiur_fn_775( + inp: [G; IN_775], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_749], ExecError> { +) -> Result<[G; OUT_775], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_749] = [__v_0]; - if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_775] = [__v_0]; + if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[749].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_749(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_749] = unsafe { *(result.output.as_ptr() as *const [G; OUT_749]) }; __ret } } else { aiur_fn_749(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[775].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_775(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_775] = unsafe { *(result.output.as_ptr() as *const [G; OUT_775]) }; __ret } } else { aiur_fn_775(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -63261,8 +65245,8 @@ fn aiur_fn_749( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_749] = [__v_7]; - if let Some(result) = record.function_queries[749].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[749].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_775] = [__v_7]; + if let Some(result) = record.function_queries[775].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[775].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63274,15 +65258,15 @@ fn aiur_fn_749( }) } -const INPUT_SIZE_750: usize = 1; -const IN_750: usize = 1; -const OUT_750: usize = 1; -fn aiur_fn_750( - inp: [G; IN_750], +const INPUT_SIZE_776: usize = 1; +const IN_776: usize = 1; +const OUT_776: usize = 1; +fn aiur_fn_776( + inp: [G; IN_776], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_750], ExecError> { +) -> Result<[G; OUT_776], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; @@ -63294,17 +65278,17 @@ fn aiur_fn_750( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_750] = [__v_6]; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_776] = [__v_6]; + if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[750].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_750(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_750] = unsafe { *(result.output.as_ptr() as *const [G; OUT_750]) }; __ret } } else { aiur_fn_750(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[776].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_776(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_776] = unsafe { *(result.output.as_ptr() as *const [G; OUT_776]) }; __ret } } else { aiur_fn_776(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); let __v_8: G = (__v_6 + __v_7); - let __ret: [G; OUT_750] = [__v_8]; - if let Some(result) = record.function_queries[750].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[750].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_776] = [__v_8]; + if let Some(result) = record.function_queries[776].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[776].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63314,15 +65298,15 @@ fn aiur_fn_750( }) } -const INPUT_SIZE_751: usize = 8; -const IN_751: usize = 8; -const OUT_751: usize = 6; -fn aiur_fn_751( - inp: [G; IN_751], +const INPUT_SIZE_777: usize = 8; +const IN_777: usize = 8; +const OUT_777: usize = 6; +fn aiur_fn_777( + inp: [G; IN_777], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_751], ExecError> { +) -> Result<[G; OUT_777], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63332,7 +65316,7 @@ fn aiur_fn_751( let __v_5: G = inp[5]; let __v_6: G = inp[6]; let __v_7: G = inp[7]; - let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__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[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; @@ -63343,8 +65327,8 @@ fn aiur_fn_751( 0u64 => { let __v_14: G = G::from_u64(0); let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_751] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; - if let Some(result) = record.function_queries[751].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[751].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_777] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; + if let Some(result) = record.function_queries[777].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[777].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63354,15 +65338,15 @@ fn aiur_fn_751( }) } -const INPUT_SIZE_752: usize = 9; -const IN_752: usize = 9; -const OUT_752: usize = 1; -fn aiur_fn_752( - inp: [G; IN_752], +const INPUT_SIZE_778: usize = 9; +const IN_778: usize = 9; +const OUT_778: usize = 1; +fn aiur_fn_778( + inp: [G; IN_778], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_752], ExecError> { +) -> Result<[G; OUT_778], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63391,17 +65375,17 @@ fn aiur_fn_752( 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_752] = [__v_23]; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_778] = [__v_23]; + if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_19: G = G::from_u64(0); - let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__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[752].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_752(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_752] = unsafe { *(result.output.as_ptr() as *const [G; OUT_752]) }; __ret } } else { aiur_fn_752(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[778].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_778(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_778] = unsafe { *(result.output.as_ptr() as *const [G; OUT_778]) }; __ret } } else { aiur_fn_778(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = { let __values: [G; 10] = [__v_19, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_752] = [__v_21]; - if let Some(result) = record.function_queries[752].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[752].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_778] = [__v_21]; + if let Some(result) = record.function_queries[778].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[778].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63411,15 +65395,15 @@ fn aiur_fn_752( }) } -const INPUT_SIZE_753: usize = 1; -const IN_753: usize = 1; -const OUT_753: usize = 1; -fn aiur_fn_753( - inp: [G; IN_753], +const INPUT_SIZE_779: usize = 1; +const IN_779: usize = 1; +const OUT_779: usize = 1; +fn aiur_fn_779( + inp: [G; IN_779], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_753], ExecError> { +) -> Result<[G; OUT_779], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; @@ -63432,17 +65416,17 @@ fn aiur_fn_753( match __v_1.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(0); - let __ret: [G; OUT_753] = [__v_7]; - if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_7]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[753].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_753(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_753] = unsafe { *(result.output.as_ptr() as *const [G; OUT_753]) }; __ret } } else { aiur_fn_753(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[779].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_779(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_779] = unsafe { *(result.output.as_ptr() as *const [G; OUT_779]) }; __ret } } else { aiur_fn_779(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_7 + __v_8); - let __ret: [G; OUT_753] = [__v_9]; - if let Some(result) = record.function_queries[753].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[753].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_779] = [__v_9]; + if let Some(result) = record.function_queries[779].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[779].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63452,15 +65436,15 @@ fn aiur_fn_753( }) } -const INPUT_SIZE_754: usize = 2; -const IN_754: usize = 2; -const OUT_754: usize = 1; -fn aiur_fn_754( - inp: [G; IN_754], +const INPUT_SIZE_780: usize = 2; +const IN_780: usize = 2; +const OUT_780: usize = 1; +fn aiur_fn_780( + inp: [G; IN_780], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_754], ExecError> { +) -> Result<[G; OUT_780], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63470,17 +65454,17 @@ fn aiur_fn_754( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_754] = [__v_1]; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_780] = [__v_1]; + if let Some(result) = record.function_queries[780].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); let __v_6: G = { let __values: [G; 3] = [__v_5, __v_3, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[754].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_754(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_754] = unsafe { *(result.output.as_ptr() as *const [G; OUT_754]) }; __ret } } else { aiur_fn_754(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[780].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_780(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_780] = unsafe { *(result.output.as_ptr() as *const [G; OUT_780]) }; __ret } } else { aiur_fn_780(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_754] = [__v_7]; - if let Some(result) = record.function_queries[754].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[754].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_780] = [__v_7]; + if let Some(result) = record.function_queries[780].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[780].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63490,15 +65474,15 @@ fn aiur_fn_754( }) } -const INPUT_SIZE_755: usize = 8; -const IN_755: usize = 8; -const OUT_755: usize = 6; -fn aiur_fn_755( - inp: [G; IN_755], +const INPUT_SIZE_781: usize = 8; +const IN_781: usize = 8; +const OUT_781: usize = 6; +fn aiur_fn_781( + inp: [G; IN_781], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_755], ExecError> { +) -> Result<[G; OUT_781], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63518,8 +65502,8 @@ fn aiur_fn_755( 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_755] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; - if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_781] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; + if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, 0u64 => { @@ -63540,22 +65524,22 @@ fn aiur_fn_755( 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_755] = { let __args: [G; IN_755] = [__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[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __v_23: G = __r_arr[2]; let __v_24: G = __r_arr[3]; let __v_25: G = __r_arr[4]; let __v_26: G = __r_arr[5]; - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__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[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_4, __v_5, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_782(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } } else { aiur_fn_782(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; let __v_29: G = __r_arr[2]; let __v_30: G = __r_arr[3]; let __v_31: G = __r_arr[4]; let __v_32: G = __r_arr[5]; - let __ret: [G; OUT_755] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; - if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_781] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63565,27 +65549,27 @@ fn aiur_fn_755( 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_755] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; - if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_781] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; + if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__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[755].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_755(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_755] = unsafe { *(result.output.as_ptr() as *const [G; OUT_755]) }; __ret } } else { aiur_fn_755(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[781].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_781(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_781] = unsafe { *(result.output.as_ptr() as *const [G; OUT_781]) }; __ret } } else { aiur_fn_781(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; let __v_26: G = __r_arr[4]; let __v_27: G = __r_arr[5]; - let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__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[756].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_756(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_756] = unsafe { *(result.output.as_ptr() as *const [G; OUT_756]) }; __ret } } else { aiur_fn_756(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[782].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_782(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_782] = unsafe { *(result.output.as_ptr() as *const [G; OUT_782]) }; __ret } } else { aiur_fn_782(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; let __v_31: G = __r_arr[3]; let __v_32: G = __r_arr[4]; let __v_33: G = __r_arr[5]; - let __ret: [G; OUT_755] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; - if let Some(result) = record.function_queries[755].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[755].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_781] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + if let Some(result) = record.function_queries[781].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[781].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63599,15 +65583,15 @@ fn aiur_fn_755( }) } -const INPUT_SIZE_756: usize = 15; -const IN_756: usize = 15; -const OUT_756: usize = 6; -fn aiur_fn_756( - inp: [G; IN_756], +const INPUT_SIZE_782: usize = 15; +const IN_782: usize = 15; +const OUT_782: usize = 6; +fn aiur_fn_782( + inp: [G; IN_782], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_756], ExecError> { +) -> Result<[G; OUT_782], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63626,38 +65610,38 @@ fn aiur_fn_756( let __v_14: G = inp[14]; match __v_0.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_1, __v_2, __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[757].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_757(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_757] = unsafe { *(result.output.as_ptr() as *const [G; OUT_757]) }; __ret } } else { aiur_fn_757(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[783].get_mut(&__args[..]) { if !__cu && *result.multiplicity == G::ZERO { aiur_fn_783(__args, record, io_buffer, false)? } else { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_783] = unsafe { *(result.output.as_ptr() as *const [G; OUT_783]) }; __ret } } else { aiur_fn_783(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; let __v_18: G = __r_arr[3]; let __v_19: G = __r_arr[4]; let __v_20: G = __r_arr[5]; - let __ret: [G; OUT_756] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; - if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_782] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; + if let Some(result) = record.function_queries[782].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 6] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_17: G = { let __values: [G; 6] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_756] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; - if let Some(result) = record.function_queries[756].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[756].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_782] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; + if let Some(result) = record.function_queries[782].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[782].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } }) } -const INPUT_SIZE_757: usize = 14; -const IN_757: usize = 14; -const OUT_757: usize = 6; -fn aiur_fn_757( - inp: [G; IN_757], +const INPUT_SIZE_783: usize = 14; +const IN_783: usize = 14; +const OUT_783: usize = 6; +fn aiur_fn_783( + inp: [G; IN_783], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_757], ExecError> { +) -> Result<[G; OUT_783], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -63697,8 +65681,8 @@ fn aiur_fn_757( 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_757] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63722,8 +65706,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63751,8 +65735,8 @@ fn aiur_fn_757( 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_757] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63776,8 +65760,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63785,8 +65769,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63796,8 +65780,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63825,8 +65809,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63834,8 +65818,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63845,8 +65829,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63858,8 +65842,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63869,8 +65853,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63902,8 +65886,8 @@ fn aiur_fn_757( 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_757] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63927,8 +65911,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63936,8 +65920,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63947,8 +65931,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63976,8 +65960,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -63985,8 +65969,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -63996,8 +65980,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64009,8 +65993,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64020,8 +66004,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64051,8 +66035,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64080,8 +66064,8 @@ fn aiur_fn_757( 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_757] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64105,8 +66089,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64114,8 +66098,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64125,8 +66109,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64154,8 +66138,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64163,8 +66147,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64174,8 +66158,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64187,8 +66171,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64198,8 +66182,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64231,8 +66215,8 @@ fn aiur_fn_757( 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_757] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64256,8 +66240,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64265,8 +66249,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64276,8 +66260,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64305,8 +66289,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64314,8 +66298,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64325,8 +66309,8 @@ fn aiur_fn_757( 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_757] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64338,8 +66322,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64349,8 +66333,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64384,8 +66368,8 @@ fn aiur_fn_757( 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_757] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64409,8 +66393,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64418,8 +66402,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64429,8 +66413,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64458,8 +66442,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64467,8 +66451,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64478,8 +66462,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64491,8 +66475,8 @@ fn aiur_fn_757( 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_757] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64502,8 +66486,8 @@ fn aiur_fn_757( 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_757] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64535,8 +66519,8 @@ fn aiur_fn_757( 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_757] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64560,8 +66544,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64569,8 +66553,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64580,8 +66564,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64609,8 +66593,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, _ => { @@ -64618,8 +66602,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64629,8 +66613,8 @@ fn aiur_fn_757( 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_757] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64642,8 +66626,8 @@ fn aiur_fn_757( 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_757] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -64653,8 +66637,8 @@ fn aiur_fn_757( 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_757] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; - if let Some(result) = record.function_queries[757].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[757].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; + let __ret: [G; OUT_783] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + if let Some(result) = record.function_queries[783].get_mut(&inp[..]) { debug_assert_eq!(result.output, &__ret[..]); if !unconstrained { *result.multiplicity += G::ONE; } } else { record.function_queries[783].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); }; return Ok(__ret); }, } @@ -68460,6 +70444,136 @@ pub(crate) fn execute_generated( let __out = aiur_fn_757(__inp, record, io_buffer, false)?; return Ok(__out.to_vec()); }, + 758u64 => { + let __inp: [G; IN_758] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_758(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 759u64 => { + let __inp: [G; IN_759] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_759(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 760u64 => { + let __inp: [G; IN_760] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_760(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 761u64 => { + let __inp: [G; IN_761] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_761(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 762u64 => { + let __inp: [G; IN_762] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_762(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 763u64 => { + let __inp: [G; IN_763] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_763(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 764u64 => { + let __inp: [G; IN_764] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_764(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 765u64 => { + let __inp: [G; IN_765] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_765(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 766u64 => { + let __inp: [G; IN_766] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_766(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 767u64 => { + let __inp: [G; IN_767] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_767(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 768u64 => { + let __inp: [G; IN_768] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_768(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 769u64 => { + let __inp: [G; IN_769] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_769(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 770u64 => { + let __inp: [G; IN_770] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_770(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 771u64 => { + let __inp: [G; IN_771] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_771(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 772u64 => { + let __inp: [G; IN_772] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_772(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 773u64 => { + let __inp: [G; IN_773] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_773(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 774u64 => { + let __inp: [G; IN_774] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_774(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 775u64 => { + let __inp: [G; IN_775] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_775(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 776u64 => { + let __inp: [G; IN_776] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_776(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 777u64 => { + let __inp: [G; IN_777] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_777(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 778u64 => { + let __inp: [G; IN_778] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_778(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 779u64 => { + let __inp: [G; IN_779] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_779(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 780u64 => { + let __inp: [G; IN_780] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_780(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 781u64 => { + let __inp: [G; IN_781] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_781(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 782u64 => { + let __inp: [G; IN_782] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_782(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 783u64 => { + let __inp: [G; IN_783] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_783(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); },