From 7eac68a027490edec0aa15ab6074ea027a0bffff Mon Sep 17 00:00:00 2001 From: Gabriel Barreto Date: Thu, 30 Jul 2026 13:39:19 -0300 Subject: [PATCH 1/4] multi-stark logUp grouping: adopt in the vk codec and recursive verifier Bump multi-stark to the circuit-local lookup-grouping rev (07dc89d): one chained accumulator step may consume k consecutive messages, (prod_j m_j) * (acc' - acc) - sum_j mult_j * prod_{j'!=j} m_{j'} = 0 committing ceil(L/k) accumulator slots instead of L at the cost of a higher logUp constraint degree. The group size is a free per-circuit choice (it changes the constraint structure, not just the counts), so the vk serializes it: a u8 after max_constraint_degree in each circuit record, validated against MAX_LOOKUP_GROUP on decode, with the derived stage_2_width and constraint_count now ceil(L/k)-based. Aiur keeps lookup_group_size = 1 for every circuit for now, which reproduces the previous protocol exactly except for the transcript shape. Lean mirror: - SystemDeserialize reads the group-size byte and derives ceil(L/k) in-circuit by walking the lookups with a countdown (no division); the observed shape is now 7 limbs per circuit (observe_shape gained lookup_group_size after stage_2_width). - The verifier's logup_steps_fold evaluates one constraint per lookup GROUP, building each group's message product P and numerator R in a single pass via R <- R*m + mult*P; P <- P*m; at k = 1 this is exactly the old per-lookup chained step. The wrap group targets the next row's slot 0 plus the is_last_row-scaled injection, unchanged. The codec round-trip test covers a k = 2 circuit; the recursive verifier e2e suite (prove -> verify in-circuit -> reject tampering) passes against the new format, as do the aiur and multi-stark suites. Codegen regenerated. --- Cargo.lock | 2 +- Cargo.toml | 2 +- Ix/MultiStark/SystemDeserialize.lean | 68 +- Ix/MultiStark/Verifier.lean | 92 +- crates/aiur/src/synthesis.rs | 1 + crates/aiur/src/vk_codec.rs | 47 +- crates/ixvm-codegen/src/aiur_multi_stark.rs | 4426 ++++++++++--------- 7 files changed, 2479 insertions(+), 2159 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9bcffa277..f0bdc852f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2077,7 +2077,7 @@ dependencies = [ [[package]] name = "multi-stark" version = "0.1.0" -source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=be1755e216691a2a7856c818ee83f5488cd2d90f#be1755e216691a2a7856c818ee83f5488cd2d90f" +source = "git+https://github.com/argumentcomputer/multi-stark.git?rev=e2c13449e63410bcfee95d7bfc83df2866f6bfbc#e2c13449e63410bcfee95d7bfc83df2866f6bfbc" dependencies = [ "bincode", "p3-air", diff --git a/Cargo.toml b/Cargo.toml index b4cc3788a..6e9ac482b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -51,7 +51,7 @@ libc = "0.2" log = "0.4" memmap2 = "0.9" mimalloc = { version = "0.1", default-features = false } -multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "be1755e216691a2a7856c818ee83f5488cd2d90f" } +multi-stark = { git = "https://github.com/argumentcomputer/multi-stark.git", rev = "e2c13449e63410bcfee95d7bfc83df2866f6bfbc" } nom = "7.1.3" num-bigint = "0.4.6" quickcheck = "1.0.3" diff --git a/Ix/MultiStark/SystemDeserialize.lean b/Ix/MultiStark/SystemDeserialize.lean index 16ee230ca..9e742a879 100644 --- a/Ix/MultiStark/SystemDeserialize.lean +++ b/Ix/MultiStark/SystemDeserialize.lean @@ -20,7 +20,9 @@ flat base-field node graph, so this reader parses that compiled form: constraint_count, stage_2_width, num_publics, and lookup_prefix_len are all recomputed from the counts below): - u16 main_width, u16 preprocessed_width, u32 preprocessed_height, - u16 max_constraint_degree (combined user + logUp), u16 node_count + u16 max_constraint_degree (combined user + logUp), + u8 lookup_group_size (k: lookups per chained accumulator step), + u16 node_count - `node_count` tagged nodes (dense v5: u16 children, never sub-trees): 0 ConstSmall(u16) · 1 ConstBig(u64) · 2 Public(u8) · 3 IsFirstRow · 4 IsLastRow · 5 IsTransition · @@ -42,10 +44,10 @@ over the whole arena, bound to the public `system_digest`) is what makes the bytes meaningful. Per-node degrees are neither serialized nor needed (the node sweep just evaluates the graph). -The Fiat-Shamir shape limbs are unchanged from v2: `observe_shape` still -feeds the challenger the circuit count then, per circuit, the six words -constraint_count, max_constraint_degree, preprocessed_height, -preprocessed_width, main_width, stage_2_width (as 8-byte LE limbs). +The Fiat-Shamir shape limbs (`observe_shape`): the circuit count then, +per circuit, the seven words constraint_count, max_constraint_degree, +preprocessed_height, preprocessed_width, main_width, stage_2_width, +lookup_group_size (as 8-byte LE limbs). -/ public section @@ -81,7 +83,7 @@ def systemDeserialize := ⟦ -- A compiled lookup: multiplicity node id + argument node ids (all into -- the graph's lookup prefix). Drives the direct logUp evaluation. enum SysLookup { Mk(G, List‹G›) } - enum SysCircuit { Mk(List‹SysNode›, G, List‹G›, G, List‹SysLookup›) } -- nodes, node_count, zeros, max_constraint_degree, lookups + enum SysCircuit { Mk(List‹SysNode›, G, List‹G›, G, List‹SysLookup›, G) } -- nodes, node_count, zeros, max_constraint_degree, lookups, lookup_group_size -- log_blowup, cap_height, log_final_poly_len, max_log_arity, num_queries, -- commit_proof_of_work_bits, query_proof_of_work_bits — the commitment + FRI @@ -255,52 +257,68 @@ def systemDeserialize := ⟦ } } + -- ⌈n/k⌉ by walking the lookups with a within-group countdown (`rem`, + -- 0 = a new group starts on the next lookup). No in-circuit division. + fn lookup_groups_count(n: G, rem: G, k: G) -> G { + match n { + 0 => 0, + _ => match rem { + 0 => 1 + lookup_groups_count(n - 1, k - 1, k), + _ => lookup_groups_count(n - 1, rem - 1, k), + }, + } + } + -- One circuit record: a u32 length prefix then the contiguous record. The -- 8-word header, the node stream, the zeros, and the compiled lookups -- (which drive the direct logUp evaluation) are all parsed. Besides the - -- parsed circuit, returns its 6 shape words as u64 limbs, in - -- `observe_shape` order: constraint_count (user roots + (L+3)·D, read + -- parsed circuit, returns its 7 shape words as u64 limbs, in + -- `observe_shape` order: constraint_count (user roots + ⌈L/k⌉·D, read -- from the header), max_constraint_degree (combined), - -- preprocessed_height, preprocessed_width, main_width, stage_2_width. - fn read_sys_circuit(base: G) -> (SysCircuit, [U64; 6], G) { + -- preprocessed_height, preprocessed_width, main_width, stage_2_width, + -- lookup_group_size. + fn read_sys_circuit(base: G) -> (SysCircuit, [U64; 7], G) { let (mw, mwl, c1) = #read_vk_u16_limb(base); let (pw, pwl, c2) = #read_vk_u16_limb(c1); let (ph, phl, c3) = #read_vk_u32_limb(c2); let (md, mdl, c4) = #read_vk_u16_limb(c3); - let (ncount, c5) = #read_vk_u16(c4); + let (k, c4b) = #read_vk_tag(c4); + let (ncount, c5) = #read_vk_u16(c4b); let (nodes, c6) = read_nodes_n(c5, ncount); let (zcount, c7) = #read_vk_u16(c6); let (zeros, c8) = read_node_ids_n(c7, zcount); let (lcount, c9) = #read_vk_u16(c8); let (lks, c10) = read_sys_lookups_n(c9, lcount); -- Derived shape values (not serialized): constraint_count = user roots - -- + (L+3)·D and stage_2_width = (1+L)·D, their observation limbs built - -- by byte decomposition (both values are far below 2^32, so the - -- canonical decomposition IS the little-endian u64 limb). - -- Chained logUp: max(L, 1) accumulator slots, one constraint per slot. - let lslots = match lcount { + -- + ⌈L/k⌉·D and stage_2_width = max(⌈L/k⌉, 1)·D, their observation + -- limbs built by byte decomposition (both values are far below 2^32, so + -- the canonical decomposition IS the little-endian u64 limb). + -- Grouped chained logUp: one accumulator slot and one constraint per + -- lookup GROUP (`k` consecutive lookups; the last group may be smaller). + let gslots = match lcount { 0 => 1, - _ => lcount, + _ => lookup_groups_count(lcount, 0, k), }; - let ccl = gl_to_bytes(zcount + lslots + lslots); - let s2wl = gl_to_bytes(lslots + lslots); - (SysCircuit.Mk(nodes, ncount, zeros, md, lks), - [ccl, mdl, phl, pwl, mwl, s2wl], c10) + let ccl = gl_to_bytes(zcount + gslots + gslots); + let s2wl = gl_to_bytes(gslots + gslots); + let kl = gl_to_bytes(k); + (SysCircuit.Mk(nodes, ncount, zeros, md, lks, k), + [ccl, mdl, phl, pwl, mwl, s2wl, kl], c10) } - fn cons_shape6(l: [U64; 6], tail: List‹U64›) -> List‹U64› { + fn cons_shape7(l: [U64; 7], tail: List‹U64›) -> List‹U64› { store(ListNode.Cons(l[0], store(ListNode.Cons(l[1], store(ListNode.Cons(l[2], store(ListNode.Cons(l[3], store(ListNode.Cons(l[4], store(ListNode.Cons(l[5], - tail)))))))))))) + store(ListNode.Cons(l[6], tail)))))))))))))) } -- Returns the circuits plus their shape limbs (`observe_shape` order: each - -- circuit's 6 metadata words; the count limb is consed by `read_system`). + -- circuit's 7 metadata words; the count limb is consed by `read_system`). fn read_sys_circuits_n(i: G, n: G) -> (List‹SysCircuit›, List‹U64›, G) { match n { 0 => (store(ListNode.Nil), store(ListNode.Nil), i), _ => let (x, xl, j) = read_sys_circuit(i); let (rest, lrest, j2) = read_sys_circuits_n(j, n - 1); - (store(ListNode.Cons(x, rest)), cons_shape6(xl, lrest), j2), + (store(ListNode.Cons(x, rest)), cons_shape7(xl, lrest), j2), } } diff --git a/Ix/MultiStark/Verifier.lean b/Ix/MultiStark/Verifier.lean index d64641352..fc2cddc82 100644 --- a/Ix/MultiStark/Verifier.lean +++ b/Ix/MultiStark/Verifier.lean @@ -623,9 +623,8 @@ def verifier := ⟦ -- machinery, never compiled into the vk's node graph: their values at ζ -- are computed here from the lookup ids (evaluated through the memoized -- `eval_at`), the stage-2 openings, and the lookup publics, and folded - -- with α after the user roots — per lookup the 2 coordinates of - -- `(β + fingerprint(γ, args))·inv − 1`, then the first-row, transition, - -- and last-row accumulator constraints (2 coordinates each). + -- with α after the user roots — per lookup GROUP the 2 coordinates of + -- the chained-accumulator step constraint (see `logup_steps_fold`). -- -- Coordinates: a coordinate-expanded logUp constraint is a PAIR of -- base-field polynomials; at ζ each coordinate is an Ext value. Pair @@ -655,20 +654,21 @@ def verifier := ⟦ } } - -- Per-lookup message constraints, folding into the α accumulator as we - -- go and accumulating `acc_expr = acc_col + Σⱼ multⱼ·invⱼ` (as a - -- coordinate pair) for the accumulator constraints. `j` is the lookup - -- slot (inverse columns at stage-2 slots 1+j). - -- One chained-accumulator step per lookup (Rust - -- `lookup::logup_constraint_values`): stage-2 slot `j` holds `acc_j`, the - -- running sum entering lookup `j`'s step. Interior steps assert - -- `m_j·(acc_{j+1} − acc_j) − mult_j = 0`; the wrap step (j = L−1) targets - -- the NEXT row's slot 0 plus the boundary injection - -- `is_last_row·(acc_final − acc_initial)` (`inj`), which converts the - -- cyclic telescoped sum into the public accumulator difference. - -- `is_last_row` is normalized (`trace_selectors`), so no row-position - -- constraints exist besides the injection. + -- Per-GROUP chained-accumulator constraints, folding into the α + -- accumulator as we go (Rust `lookup::logup_constraint_values`): stage-2 + -- slot `g` holds `acc_g`, the running sum entering group `g`'s step. A + -- group of `k` consecutive lookups (the last group may be smaller) + -- asserts `(Π_j m_j)·(acc_{g+1} − acc_g) − Σ_j mult_j·Π_{j'≠j} m_{j'}`; + -- the wrap step (last group) targets the NEXT row's slot 0 plus the + -- boundary injection `is_last_row·(acc_final − acc_initial)` (`inj`), + -- which converts the cyclic telescoped sum into the public accumulator + -- difference. Group state is built in one pass with the recurrence + -- `R ← R·m + mult·P; P ← P·m` (P the message product, R the mult sum); + -- `rem` counts the group's remaining capacity, `j` the lookup index. + -- Ungrouped (k = 1) closes every step: P = m, R = (mult, 0), exactly the + -- per-lookup chained constraint. fn logup_steps_fold(acc: Ext, alpha: Ext, lks: List‹SysLookup›, j: G, lcount: G, + g: G, rem: G, k: G, p0: Ext, p1: Ext, r0: Ext, r1: Ext, inj0: Ext, inj1: Ext, b0: Ext, b1: Ext, g0: Ext, g1: Ext, nodes: List‹SysNode›, main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›, @@ -678,23 +678,49 @@ def verifier := ⟦ ListNode.Nil => acc, ListNode.Cons(lk, rest) => let SysLookup.Mk(mid, args) = lk; - let s0 = list_lookup(s2, j + j); - let s1 = list_lookup(s2, j + j + 1); - let (t0, t1) = match (j + 1 - lcount) { - 0 => (eg_add(list_lookup(s2next, 0), inj0), - eg_add(list_lookup(s2next, 1), inj1)), - _ => (list_lookup(s2, j + j + 2), list_lookup(s2, j + j + 3)), - }; let (f0, f1) = logup_fingerprint(args, g0, g1, nodes, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist); - let (c0, c1) = pair_mul(eg_add(f0, b0), eg_add(f1, b1), - eg_sub(t0, s0), eg_sub(t1, s1)); + let m0 = eg_add(f0, b0); + let m1 = eg_add(f1, b1); let mv = eval_at(nodes, mid, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist); - let acc1 = ood_fold(ood_fold(acc, alpha, eg_sub(c0, mv)), alpha, c1); - logup_steps_fold(acc1, alpha, rest, j + 1, lcount, inj0, inj1, - b0, b1, g0, g1, nodes, - main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), + -- R ← R·m + mult·P, then P ← P·m. + let (rm0, rm1) = pair_mul(r0, r1, m0, m1); + let nr0 = eg_add(rm0, eg_mul(mv, p0)); + let nr1 = eg_add(rm1, eg_mul(mv, p1)); + let (np0, np1) = pair_mul(p0, p1, m0, m1); + match (j + 1 - lcount) { + 0 => + -- Final lookup: close the (possibly smaller) last group against + -- the wrap target. + let s0 = list_lookup(s2, g + g); + let s1 = list_lookup(s2, g + g + 1); + let t0 = eg_add(list_lookup(s2next, 0), inj0); + let t1 = eg_add(list_lookup(s2next, 1), inj1); + let (c0, c1) = pair_mul(np0, np1, eg_sub(t0, s0), eg_sub(t1, s1)); + ood_fold(ood_fold(acc, alpha, eg_sub(c0, nr0)), alpha, eg_sub(c1, nr1)), + _ => match rem - 1 { + 0 => + -- Group full: close against the next slot, reset the state. + let s0 = list_lookup(s2, g + g); + let s1 = list_lookup(s2, g + g + 1); + let t0 = list_lookup(s2, g + g + 2); + let t1 = list_lookup(s2, g + g + 3); + let (c0, c1) = pair_mul(np0, np1, eg_sub(t0, s0), eg_sub(t1, s1)); + let acc1 = ood_fold(ood_fold(acc, alpha, eg_sub(c0, nr0)), alpha, + eg_sub(c1, nr1)); + logup_steps_fold(acc1, alpha, rest, j + 1, lcount, + g + 1, k, k, [1, 0], [0, 0], [0, 0], [0, 0], + inj0, inj1, b0, b1, g0, g1, nodes, + main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), + _ => + -- Keep accumulating within the group. + logup_steps_fold(acc, alpha, rest, j + 1, lcount, + g, rem - 1, k, np0, np1, nr0, nr1, + inj0, inj1, b0, b1, g0, g1, nodes, + main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), + }, + }, } } @@ -703,6 +729,7 @@ def verifier := ⟦ -- directly-evaluated chained-logUp step values, all Horner-folded with α -- in the canonical protocol order. fn ood_composition(nodes: List‹SysNode›, zeros: List‹G›, lks: List‹SysLookup›, + k: G, main: List‹Ext›, main_next: List‹Ext›, prep: List‹Ext›, prep_next: List‹Ext›, s2: List‹Ext›, s2next: List‹Ext›, publics: List‹Ext›, isf: Ext, isl: Ext, ist: Ext, alpha: Ext, inorm: G) -> Ext { @@ -727,7 +754,8 @@ def verifier := ⟦ ood_fold(acc, alpha, eg_add(eg_sub(list_lookup(s2next, 1), list_lookup(s2, 1)), inj1)), ListNode.Cons(_h, _t) => - logup_steps_fold(base, alpha, lks, 0, list_length(lks), inj0, inj1, + logup_steps_fold(base, alpha, lks, 0, list_length(lks), + 0, k, k, [1, 0], [0, 0], [0, 0], [0, 0], inj0, inj1, b0, b1, g0, g1, nodes, main, main_next, prep, prep_next, s2, s2next, publics, isf, isl, ist), } @@ -807,7 +835,7 @@ def verifier := ⟦ match load(circuits) { ListNode.Nil => 1, ListNode.Cons(circ, rest) => - let SysCircuit.Mk(nodes, _node_count, zeros, md, lks) = circ; + let SysCircuit.Mk(nodes, _node_count, zeros, md, lks, k) = circ; let l = to_field(list_lookup(log_degrees, i)); let qd = quotient_degree_of(md); let naccp = list_lookup(accs, i); @@ -822,7 +850,7 @@ def verifier := ⟦ let (isf, isl, ist, invv) = trace_selectors(zeta, l); let publics = build_publics(lch, fch, accp, naccp); let inorm = gl_inverse(pow2(l) * two_adic_gen(l)); - let comp = ood_composition(nodes, zeros, lks, + let comp = ood_composition(nodes, zeros, lks, k, main, main_next, prep, prep_next, s2row, s2next, publics, isf, isl, ist, alpha, inorm); -- circuit i's wide quotient row, its base-coordinate pairs folded back diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 9f886f3f2..3d0ca55e8 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -71,6 +71,7 @@ impl AiurSystem { constraints, ext_constraints: vec![], lookups, + lookup_group_size: 1, }); }; diff --git a/crates/aiur/src/vk_codec.rs b/crates/aiur/src/vk_codec.rs index 554cecfb4..9fa9e00ec 100644 --- a/crates/aiur/src/vk_codec.rs +++ b/crates/aiur/src/vk_codec.rs @@ -30,10 +30,9 @@ //! u16 circuit count //! PER-CIRCUIT RECORDS (circuit count times; each is `u32 LE len` + `len` bytes //! so a record is a contiguous byte range) -//! 8 x u32 LE main_width, preprocessed_width, preprocessed_height, -//! constraint_count (user roots + (L+3)*D), stage_2_width, -//! max_constraint_degree (combined user + logUp), -//! lookup_prefix_len, node_count +//! u16 main_width, u16 preprocessed_width, u32 preprocessed_height, +//! u16 max_constraint_degree (combined user + logUp), +//! u8 lookup_group_size (k: lookups per chained accumulator step) //! node_count nodes, each a u8 tag then payload: //! 0 ConstSmall: u16 LE canonical value //! 1 ConstBig: u64 LE canonical value @@ -157,7 +156,8 @@ fn push_node(buf: &mut Vec, node: &Node) { } /// One circuit record. Nothing derivable is serialized: `constraint_count` -/// (= zeros + (L+3)·D), `stage_2_width` (= (1+L)·D), `num_publics` (= 4·D), +/// (= zeros + ⌈L/k⌉·D), `stage_2_width` (= max(⌈L/k⌉, 1)·D), `num_publics` +/// (= 4·D), /// and `lookup_prefix_len` (= 1 + max node id reachable from the lookups) /// are all recomputed on decode, and the Lean reader derives the observed /// shape limbs the same way. @@ -170,6 +170,10 @@ fn encode_circuit(buf: &mut Vec, circuit: &Circuit) { // Combined max degree (user graph + analytic logUp), as observed. Not // derivable cheaply in-circuit (it would need a full degree pass). push_u16(buf, circuit.max_constraint_degree); + // The lookup group size is a free per-circuit choice (it changes the + // constraint structure, not just counts), so it must be serialized. + buf + .push(u8::try_from(circuit.lookup_group_size).expect("group size fits u8")); push_u16(buf, compiled.nodes.len()); for node in &compiled.nodes { push_node(buf, node); @@ -339,6 +343,10 @@ fn decode_circuit(seg: &mut Seg<'_>) -> Result, String> { let preprocessed_width = seg.u16()? as usize; let preprocessed_height = seg.u32_usize()?; let max_constraint_degree = seg.u16()? as usize; + let lookup_group_size = seg.u8()? as usize; + if !(1..=multi_stark::lookup::MAX_LOOKUP_GROUP).contains(&lookup_group_size) { + return Err(format!("bad lookup group size {lookup_group_size}")); + } let node_count = seg.u16()? as usize; let mut nodes = Vec::with_capacity(node_count); for _ in 0..node_count { @@ -398,17 +406,33 @@ fn decode_circuit(seg: &mut Seg<'_>) -> Result, String> { preprocessed_width, preprocessed_height, num_lookups, - stage_2_width: multi_stark::lookup::stage2_width(num_lookups, ext_degree), + stage_2_width: multi_stark::lookup::stage2_width( + num_lookups, + lookup_group_size, + ext_degree, + ), num_publics: multi_stark::lookup::num_publics(ext_degree), - constraint_count: zeros_plus_logup(zero_count, num_lookups, ext_degree), + lookup_group_size, + constraint_count: zeros_plus_logup( + zero_count, + num_lookups, + lookup_group_size, + ext_degree, + ), max_constraint_degree, }) } /// The folded constraint count: user roots + the directly-evaluated logUp /// values (mirrors `multi_stark::lookup::logup_constraint_count`). -fn zeros_plus_logup(zero_count: usize, num_lookups: usize, d: usize) -> usize { - zero_count + multi_stark::lookup::logup_constraint_count(num_lookups, d) +fn zeros_plus_logup( + zero_count: usize, + num_lookups: usize, + group_size: usize, + d: usize, +) -> usize { + zero_count + + multi_stark::lookup::logup_constraint_count(num_lookups, group_size, d) } /// Deserialize a `System` from [`to_bytes`] output, requiring that @@ -495,6 +519,7 @@ mod tests { constraints: vec![], ext_constraints: vec![], lookups: Bytes1.lookups(), + lookup_group_size: 1, }, CircuitInputs { main_width: Bytes2.main_width(), @@ -502,6 +527,9 @@ mod tests { constraints: vec![], ext_constraints: vec![], lookups: Bytes2.lookups(), + // Grouped-circuit coverage: the codec must carry the group size + // through (it changes the derived stage-2 width and count). + lookup_group_size: 2, }, ]; let (system, _key) = System::new(AiurConfig::new(cp, fp), inputs); @@ -527,6 +555,7 @@ mod tests { assert_eq!(la.args, lb.args); } assert_eq!(a.main_width, b.main_width); + assert_eq!(a.lookup_group_size, b.lookup_group_size); assert_eq!(a.stage_2_width, b.stage_2_width); assert_eq!(a.num_publics, b.num_publics); assert_eq!(a.preprocessed_width, b.preprocessed_width); diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs index 2e2276065..600f6568d 100644 --- a/crates/ixvm-codegen/src/aiur_multi_stark.rs +++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs @@ -4341,7 +4341,7 @@ fn aiur_fn_69( let __v_72: G = __r_arr[63]; match __v_2.as_canonical_u64() { 1023u64 => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -4499,10 +4499,10 @@ fn aiur_fn_69( return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_73: G = __r_arr[0]; let __v_74: G = (__v_73 * __v_7); - let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -6828,15 +6828,67 @@ fn aiur_fn_85( }) } -const INPUT_SIZE_86: usize = 1; -const IN_86: usize = 1; -const OUT_86: usize = 54; +const INPUT_SIZE_86: usize = 3; +const IN_86: usize = 3; +const OUT_86: usize = 1; fn aiur_fn_86( inp: [G; IN_86], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, ) -> Result<[G; OUT_86], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(0); + let __ret: [G; OUT_86] = [__v_3]; + record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(1); + let __v_5: G = (__v_0 - __v_4); + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_2 - __v_6); + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_5, __v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = (__v_3 + __v_8); + let __ret: [G; OUT_86] = [__v_9]; + record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_3: G = G::from_u64(1); + let __v_4: G = (__v_0 - __v_3); + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_86] = [__v_7]; + record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_87: usize = 1; +const IN_87: usize = 1; +const OUT_87: usize = 63; +fn aiur_fn_87( + inp: [G; IN_87], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_87], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -6883,71 +6935,86 @@ fn aiur_fn_86( 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_74] = { let __args: [G; IN_74] = [__v_40]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_40]; let __cu = true; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_42, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_42]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_44]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_44, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[82].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_82] = unsafe { *(result.output.as_ptr() as *const [G; OUT_82]) }; __ret } else { aiur_fn_82(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_46, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_46]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_47: G = __r_arr[0]; let __v_48: G = __r_arr[1]; - let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_48]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_48, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_50, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_50]; let __cu = true; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = __r_arr[1]; - let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_49.as_canonical_u64() { + let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_52, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_85] = unsafe { *(result.output.as_ptr() as *const [G; OUT_85]) }; __ret } else { aiur_fn_85(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_51.as_canonical_u64() { 0u64 => { - let __v_53: G = G::from_u64(1); - break '__mc_0 [__v_53]; + let __v_55: G = G::from_u64(1); + break '__mc_0 [__v_55]; }, _ => { - break '__mc_0 [__v_49]; + let __v_55: G = G::from_u64(0); + let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_51, __v_55, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + break '__mc_0 [__v_56]; }, } }; - let __v_53: G = __mc_out___mc_0[0]; - let __v_54: G = (__v_53 + __v_53); - let __v_55: G = (__v_45 + __v_54); - let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } }; - let __v_56: G = __r_arr[0]; - let __v_57: G = __r_arr[1]; - let __v_58: G = __r_arr[2]; - let __v_59: G = __r_arr[3]; - let __v_60: G = __r_arr[4]; - let __v_61: G = __r_arr[5]; - let __v_62: G = __r_arr[6]; - let __v_63: G = __r_arr[7]; - let __v_64: G = (__v_53 + __v_53); - let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } }; - let __v_65: G = __r_arr[0]; - let __v_66: G = __r_arr[1]; - let __v_67: G = __r_arr[2]; - let __v_68: G = __r_arr[3]; - let __v_69: G = __r_arr[4]; - let __v_70: G = __r_arr[5]; - let __v_71: G = __r_arr[6]; - let __v_72: G = __r_arr[7]; - let __ret: [G; OUT_86] = [__v_43, __v_41, __v_47, __v_31, __v_51, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_52]; - record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_55: G = __mc_out___mc_0[0]; + let __v_56: G = (__v_55 + __v_55); + let __v_57: G = (__v_47 + __v_56); + let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = __r_arr[1]; + let __v_60: G = __r_arr[2]; + let __v_61: G = __r_arr[3]; + let __v_62: G = __r_arr[4]; + let __v_63: G = __r_arr[5]; + let __v_64: G = __r_arr[6]; + let __v_65: G = __r_arr[7]; + let __v_66: G = (__v_55 + __v_55); + let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __v_68: G = __r_arr[1]; + let __v_69: G = __r_arr[2]; + let __v_70: G = __r_arr[3]; + let __v_71: G = __r_arr[4]; + let __v_72: G = __r_arr[5]; + let __v_73: G = __r_arr[6]; + let __v_74: G = __r_arr[7]; + let __r_arr: [G; OUT_12] = { let __args: [G; IN_12] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[12].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_12] = unsafe { *(result.output.as_ptr() as *const [G; OUT_12]) }; __ret } else { aiur_fn_12(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __v_76: G = __r_arr[1]; + let __v_77: G = __r_arr[2]; + let __v_78: G = __r_arr[3]; + let __v_79: G = __r_arr[4]; + let __v_80: G = __r_arr[5]; + let __v_81: G = __r_arr[6]; + let __v_82: G = __r_arr[7]; + let __ret: [G; OUT_87] = [__v_45, __v_43, __v_49, __v_31, __v_53, __v_41, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_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_54]; + record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_87: usize = 49; -const IN_87: usize = 49; -const OUT_87: usize = 1; -fn aiur_fn_87( - inp: [G; IN_87], +const INPUT_SIZE_88: usize = 57; +const IN_88: usize = 57; +const OUT_88: usize = 1; +fn aiur_fn_88( + inp: [G; IN_88], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_87], ExecError> { +) -> Result<[G; OUT_88], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -6998,33 +7065,43 @@ fn aiur_fn_87( let __v_46: G = inp[46]; let __v_47: G = inp[47]; let __v_48: G = inp[48]; - let __v_49: G = G::from_u64(0); - let __v_50: G = G::from_u64(0); - let __v_51: G = G::from_u64(0); - let __v_52: G = G::from_u64(0); - let __v_53: G = G::from_u64(0); - let __v_54: G = G::from_u64(0); - let __v_55: G = { let __values: [G; 10] = [__v_54, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_56: G = { let __values: [G; 10] = [__v_53, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_55]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_57: G = { let __values: [G; 10] = [__v_52, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_58: G = { let __values: [G; 10] = [__v_51, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_57]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_59: G = { let __values: [G; 10] = [__v_50, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_58]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __v_60: G = { let __values: [G; 10] = [__v_49, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_59]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_87] = [__v_60]; - record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __v_55: G = inp[55]; + let __v_56: G = inp[56]; + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = { let __values: [G; 10] = [__v_63, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 10] = [__v_62, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_64]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = { let __values: [G; 10] = [__v_61, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_65]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 10] = [__v_60, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_66]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 10] = [__v_59, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_67]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = { let __values: [G; 10] = [__v_58, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_68]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_70: G = { let __values: [G; 10] = [__v_57, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_88] = [__v_70]; + record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_88: usize = 2; -const IN_88: usize = 2; -const OUT_88: usize = 3; -fn aiur_fn_88( - inp: [G; IN_88], +const INPUT_SIZE_89: usize = 2; +const IN_89: usize = 2; +const OUT_89: usize = 3; +fn aiur_fn_89( + inp: [G; IN_89], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_88], ExecError> { +) -> Result<[G; OUT_89], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -7032,16 +7109,16 @@ fn aiur_fn_88( 0u64 => { let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); - let __v_4: G = { let __values: [G; 7] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_4: G = { let __values: [G; 8] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_88] = [__v_4, __v_7, __v_0]; - record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_89] = [__v_4, __v_7, __v_0]; + record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[86].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_86] = unsafe { *(result.output.as_ptr() as *const [G; OUT_86]) }; __ret } else { aiur_fn_86(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -7096,33 +7173,42 @@ fn aiur_fn_88( let __v_53: G = __r_arr[51]; let __v_54: G = __r_arr[52]; let __v_55: G = __r_arr[53]; - let __v_56: G = G::from_u64(1); - let __v_57: G = (__v_1 - __v_56); - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_55, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; - let __v_58: G = __r_arr[0]; - let __v_59: G = __r_arr[1]; - let __v_60: G = __r_arr[2]; - let __v_61: G = G::from_u64(0); - let __v_62: G = { let __values: [G; 7] = [__v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_58]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[87].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_87] = unsafe { *(result.output.as_ptr() as *const [G; OUT_87]) }; __ret } else { aiur_fn_87(__args, record, io_buffer, __cu)? } }; - let __v_63: G = __r_arr[0]; - let __ret: [G; OUT_88] = [__v_62, __v_63, __v_60]; - record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_56: G = __r_arr[54]; + let __v_57: G = __r_arr[55]; + let __v_58: G = __r_arr[56]; + let __v_59: G = __r_arr[57]; + let __v_60: G = __r_arr[58]; + let __v_61: G = __r_arr[59]; + let __v_62: G = __r_arr[60]; + let __v_63: G = __r_arr[61]; + let __v_64: G = __r_arr[62]; + let __v_65: G = G::from_u64(1); + let __v_66: G = (__v_1 - __v_65); + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_64, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __v_68: G = __r_arr[1]; + let __v_69: G = __r_arr[2]; + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 8] = [__v_70, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_67]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __v_72: G = __r_arr[0]; + let __ret: [G; OUT_89] = [__v_71, __v_72, __v_69]; + record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_89: usize = 1; -const IN_89: usize = 1; -const OUT_89: usize = 3; -fn aiur_fn_89( - inp: [G; IN_89], +const INPUT_SIZE_90: usize = 1; +const IN_90: usize = 1; +const OUT_90: usize = 3; +fn aiur_fn_90( + inp: [G; IN_90], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_89], ExecError> { +) -> Result<[G; OUT_90], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { let __ret: [G; OUT_73] = unsafe { *(result.output.as_ptr() as *const [G; OUT_73]) }; __ret } else { aiur_fn_73(__args, record, io_buffer, __cu)? } }; @@ -7132,8 +7218,8 @@ fn aiur_fn_89( 0u64 => { let __v_3: G = G::from_u64(0); let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_89] = [__v_3, __v_4, __v_2]; - record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_90] = [__v_3, __v_4, __v_2]; + record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -7144,23 +7230,23 @@ fn aiur_fn_89( let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_89] = [__v_7, __v_5, __v_6]; - record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_90] = [__v_7, __v_5, __v_6]; + record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_90: usize = 2; -const IN_90: usize = 2; -const OUT_90: usize = 2; -fn aiur_fn_90( - inp: [G; IN_90], +const INPUT_SIZE_91: usize = 2; +const IN_91: usize = 2; +const OUT_91: usize = 2; +fn aiur_fn_91( + inp: [G; IN_91], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_90], ExecError> { +) -> Result<[G; OUT_91], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -7169,8 +7255,8 @@ fn aiur_fn_90( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 4] = [__v_2, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_90] = [__v_4, __v_0]; - record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_91] = [__v_4, __v_0]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -7179,7 +7265,7 @@ fn aiur_fn_90( let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; match __v_2.as_canonical_u64() { @@ -7188,16 +7274,16 @@ fn aiur_fn_90( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_90] = [__v_11, __v_7]; - record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_91] = [__v_11, __v_7]; + record.function_queries[91].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 = { let __values: [G; 4] = [__v_8, __v_9, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_90] = [__v_10, __v_7]; - record.function_queries[90].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_91] = [__v_10, __v_7]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -7206,15 +7292,15 @@ fn aiur_fn_90( }) } -const INPUT_SIZE_91: usize = 1; -const IN_91: usize = 1; -const OUT_91: usize = 9; -fn aiur_fn_91( - inp: [G; IN_91], +const INPUT_SIZE_92: usize = 1; +const IN_92: usize = 1; +const OUT_92: usize = 9; +fn aiur_fn_92( + inp: [G; IN_92], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_91], ExecError> { +) -> Result<[G; OUT_92], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { let __ret: [G; OUT_75] = unsafe { *(result.output.as_ptr() as *const [G; OUT_75]) }; __ret } else { aiur_fn_75(__args, record, io_buffer, __cu)? } }; @@ -7311,24 +7397,24 @@ fn aiur_fn_91( let __v_85: G = { let __values: [G; 10] = [__v_73, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_84]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_86: G = { let __values: [G; 10] = [__v_72, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_85]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_87: G = { let __values: [G; 10] = [__v_71, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_86]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_91] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70]; - record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_92] = [__v_1, __v_11, __v_21, __v_31, __v_41, __v_51, __v_61, __v_87, __v_70]; + record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_92: usize = 1; -const IN_92: usize = 1; -const OUT_92: usize = 13; -fn aiur_fn_92( - inp: [G; IN_92], +const INPUT_SIZE_93: usize = 1; +const IN_93: usize = 1; +const OUT_93: usize = 13; +fn aiur_fn_93( + inp: [G; IN_93], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_92], ExecError> { +) -> Result<[G; OUT_93], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; - let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; let __v_3: G = __r_arr[2]; @@ -7349,36 +7435,36 @@ fn aiur_fn_92( let __v_17: G = __r_arr[7]; let __v_18: G = __r_arr[8]; let __v_19: G = __r_arr[9]; - let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_19, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_88] = unsafe { *(result.output.as_ptr() as *const [G; OUT_88]) }; __ret } else { aiur_fn_88(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_19, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; - let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_89] = unsafe { *(result.output.as_ptr() as *const [G; OUT_89]) }; __ret } else { aiur_fn_89(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; - let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_25, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_90] = unsafe { *(result.output.as_ptr() as *const [G; OUT_90]) }; __ret } else { aiur_fn_90(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_25, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_91] = unsafe { *(result.output.as_ptr() as *const [G; OUT_91]) }; __ret } else { aiur_fn_91(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = G::from_u64(0); let __v_29: G = { let __values: [G; 10] = [__v_28, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; - let __ret: [G; OUT_92] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_30, __v_20, __v_23, __v_24, __v_26, __v_27]; - record.function_queries[92].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_93] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_30, __v_20, __v_23, __v_24, __v_26, __v_27]; + record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_93: usize = 5; -const IN_93: usize = 5; -const OUT_93: usize = 1; -fn aiur_fn_93( - inp: [G; IN_93], +const INPUT_SIZE_94: usize = 5; +const IN_94: usize = 5; +const OUT_94: usize = 1; +fn aiur_fn_94( + inp: [G; IN_94], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_93], ExecError> { +) -> Result<[G; OUT_94], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -7393,21 +7479,21 @@ fn aiur_fn_93( let __v_10: G = { let __values: [G; 3] = [__v_7, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_11: G = { let __values: [G; 3] = [__v_6, __v_1, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_12: G = { let __values: [G; 3] = [__v_5, __v_0, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_93] = [__v_12]; - record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_94] = [__v_12]; + record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_94: usize = 33; -const IN_94: usize = 33; -const OUT_94: usize = 1; -fn aiur_fn_94( - inp: [G; IN_94], +const INPUT_SIZE_95: usize = 33; +const IN_95: usize = 33; +const OUT_95: usize = 1; +fn aiur_fn_95( + inp: [G; IN_95], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_94], ExecError> { +) -> Result<[G; OUT_95], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -7442,37 +7528,37 @@ fn aiur_fn_94( let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_24, __v_25, __v_26, __v_27, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_20, __v_21, __v_22, __v_23, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_16, __v_17, __v_18, __v_19, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_12, __v_13, __v_14, __v_15, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_8, __v_9, __v_10, __v_11, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_4, __v_5, __v_6, __v_7, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; - let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_0, __v_1, __v_2, __v_3, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __ret: [G; OUT_94] = [__v_40]; - record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_95] = [__v_40]; + record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_95: usize = 32; -const IN_95: usize = 32; -const OUT_95: usize = 32; -fn aiur_fn_95( - inp: [G; IN_95], +const INPUT_SIZE_96: usize = 32; +const IN_96: usize = 32; +const OUT_96: usize = 32; +fn aiur_fn_96( + inp: [G; IN_96], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_95], ExecError> { +) -> Result<[G; OUT_96], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -7506,21 +7592,21 @@ fn aiur_fn_95( let __v_29: G = inp[29]; let __v_30: G = inp[30]; let __v_31: G = inp[31]; - let __ret: [G; OUT_95] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; - record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_96] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; + record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_96: usize = 4; -const IN_96: usize = 4; -const OUT_96: usize = 1; -fn aiur_fn_96( - inp: [G; IN_96], +const INPUT_SIZE_97: usize = 4; +const IN_97: usize = 4; +const OUT_97: usize = 1; +fn aiur_fn_97( + inp: [G; IN_97], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_96], ExecError> { +) -> Result<[G; OUT_97], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -7528,8 +7614,8 @@ fn aiur_fn_96( let __v_3: G = inp[3]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_96] = [__v_3]; - record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_97] = [__v_3]; + record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -7541,25 +7627,25 @@ fn aiur_fn_96( let __v_8: G = (__v_2 - __v_7); let __v_9: G = G::from_u64(0); let __v_10: G = { let __values: [G; 3] = [__v_9, __v_4, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_0, __v_6, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0, __v_6, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_96] = [__v_11]; - record.function_queries[96].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_97] = [__v_11]; + record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_97: usize = 7; -const IN_97: usize = 7; -const OUT_97: usize = 1; -fn aiur_fn_97( - inp: [G; IN_97], +const INPUT_SIZE_98: usize = 7; +const IN_98: usize = 7; +const OUT_98: usize = 1; +fn aiur_fn_98( + inp: [G; IN_98], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_97], ExecError> { +) -> Result<[G; OUT_98], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -7745,8 +7831,8 @@ fn aiur_fn_97( 1u64 => { let __v_172: G = G::from_u64(0); let __v_173: G = { let __values: [G; 34] = [__v_172, __v_6, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_97] = [__v_173]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_173]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -7811,10 +7897,10 @@ fn aiur_fn_97( let __v_226: G = { let __values: [G; 32] = [__v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_227: G = G::from_u64(0); let __v_228: G = { let __values: [G; 34] = [__v_227, __v_6, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0, __v_205, __v_207, __v_208, __v_225, __v_226, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_205, __v_207, __v_208, __v_225, __v_226, __v_228]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_229: G = __r_arr[0]; - let __ret: [G; OUT_97] = [__v_229]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_229]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -7825,10 +7911,10 @@ fn aiur_fn_97( let __v_176: G = G::from_u64(1); let __v_177: G = (__v_3 + __v_176); let __v_178: G = { let __values: [G; 32] = [__v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0, __v_173, __v_175, __v_177, __v_4, __v_178, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_173, __v_175, __v_177, __v_4, __v_178, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_179: G = __r_arr[0]; - let __ret: [G; OUT_97] = [__v_179]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_179]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -8006,62 +8092,62 @@ fn aiur_fn_97( let __v_154: G = __r_arr[30]; let __v_155: G = __r_arr[31]; let __v_156: G = { let __values: [G; 34] = [__v_17, __v_6, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_97] = [__v_156]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_156]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_97] = [__v_6]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_6]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_97] = [__v_6]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_6]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_97] = [__v_6]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_6]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_97] = [__v_6]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_6]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_97] = [__v_6]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_6]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_97] = [__v_6]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_6]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_97] = [__v_6]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_6]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_97] = [__v_6]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_6]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -8070,7 +8156,7 @@ fn aiur_fn_97( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_0, __v_1, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0, __v_1, __v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(64); let __v_14: G = (__v_13 - __v_2); @@ -8235,8 +8321,8 @@ fn aiur_fn_97( let __v_166: G = __r_arr[30]; let __v_167: G = __r_arr[31]; let __v_168: G = { let __values: [G; 34] = [__v_95, __v_6, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_97] = [__v_168]; - record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_98] = [__v_168]; + record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -8245,15 +8331,15 @@ fn aiur_fn_97( }) } -const INPUT_SIZE_98: usize = 3; -const IN_98: usize = 3; -const OUT_98: usize = 32; -fn aiur_fn_98( - inp: [G; IN_98], +const INPUT_SIZE_99: usize = 3; +const IN_99: usize = 3; +const OUT_99: usize = 32; +fn aiur_fn_99( + inp: [G; IN_99], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_98], ExecError> { +) -> Result<[G; OUT_99], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8304,7 +8390,7 @@ fn aiur_fn_98( let __v_46: G = G::from_u64(1); let __v_47: G = G::from_u64(1); let __v_48: G = { let __values: [G; 34] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0, __v_1, __v_2, __v_35, __v_44, __v_45, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_0, __v_1, __v_2, __v_35, __v_44, __v_45, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; let __v_49: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_50: G = __loaded[0]; @@ -8374,21 +8460,21 @@ fn aiur_fn_98( let __v_113: G = __r_arr[29]; let __v_114: G = __r_arr[30]; let __v_115: G = __r_arr[31]; - let __ret: [G; OUT_98] = [__v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115]; - record.function_queries[98].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_99] = [__v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115]; + record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_99: usize = 64; -const IN_99: usize = 64; -const OUT_99: usize = 32; -fn aiur_fn_99( - inp: [G; IN_99], +const INPUT_SIZE_100: usize = 64; +const IN_100: usize = 64; +const OUT_100: usize = 32; +fn aiur_fn_100( + inp: [G; IN_100], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_99], ExecError> { +) -> Result<[G; OUT_100], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8529,7 +8615,7 @@ fn aiur_fn_99( let __v_135: G = __r_arr[29]; let __v_136: G = __r_arr[30]; let __v_137: G = __r_arr[31]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_138: G = __r_arr[0]; let __v_139: G = __r_arr[1]; let __v_140: G = __r_arr[2]; @@ -8562,21 +8648,21 @@ fn aiur_fn_99( let __v_167: G = __r_arr[29]; let __v_168: G = __r_arr[30]; let __v_169: G = __r_arr[31]; - let __ret: [G; OUT_99] = [__v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; - record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_100] = [__v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; + record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_100: usize = 64; -const IN_100: usize = 64; -const OUT_100: usize = 1; -fn aiur_fn_100( - inp: [G; IN_100], +const INPUT_SIZE_101: usize = 64; +const IN_101: usize = 64; +const OUT_101: usize = 1; +fn aiur_fn_101( + inp: [G; IN_101], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_100], ExecError> { +) -> Result<[G; OUT_101], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8669,21 +8755,21 @@ fn aiur_fn_100( let __v_80: G = (__v_75 * __v_79); let __v_81: G = (__v_71 * __v_80); let __v_82: G = (__v_67 * __v_81); - let __ret: [G; OUT_100] = [__v_82]; - record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_101] = [__v_82]; + record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_101: usize = 65; -const IN_101: usize = 65; -const OUT_101: usize = 32; -fn aiur_fn_101( - inp: [G; IN_101], +const INPUT_SIZE_102: usize = 65; +const IN_102: usize = 65; +const OUT_102: usize = 32; +fn aiur_fn_102( + inp: [G; IN_102], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_101], ExecError> { +) -> Result<[G; OUT_102], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8752,7 +8838,7 @@ fn aiur_fn_101( let __v_64: G = inp[64]; match __v_0.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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[99].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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[100].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -8785,12 +8871,12 @@ fn aiur_fn_101( let __v_94: G = __r_arr[29]; let __v_95: G = __r_arr[30]; let __v_96: G = __r_arr[31]; - let __ret: [G; OUT_101] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; - record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_102] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; + record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_33, __v_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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[99].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_33, __v_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_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[100].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = __r_arr[1]; let __v_67: G = __r_arr[2]; @@ -8823,23 +8909,23 @@ fn aiur_fn_101( let __v_94: G = __r_arr[29]; let __v_95: G = __r_arr[30]; let __v_96: G = __r_arr[31]; - let __ret: [G; OUT_101] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; - record.function_queries[101].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_102] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96]; + record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_102: usize = 2; -const IN_102: usize = 2; -const OUT_102: usize = 1; -fn aiur_fn_102( - inp: [G; IN_102], +const INPUT_SIZE_103: usize = 2; +const IN_103: usize = 2; +const OUT_103: usize = 1; +fn aiur_fn_103( + inp: [G; IN_103], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_102], ExecError> { +) -> Result<[G; OUT_103], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8850,8 +8936,8 @@ fn aiur_fn_102( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_102] = [__v_5]; - record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_103] = [__v_5]; + record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -8860,15 +8946,15 @@ fn aiur_fn_102( match __v_6.as_canonical_u64() { 1u64 => { let __v_7: G = G::from_u64(1); - let __ret: [G; OUT_102] = [__v_7]; - record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_103] = [__v_7]; + record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_102] = [__v_7]; - record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_103] = [__v_7]; + record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -8880,15 +8966,15 @@ fn aiur_fn_102( }) } -const INPUT_SIZE_103: usize = 3; -const IN_103: usize = 3; -const OUT_103: usize = 1; -fn aiur_fn_103( - inp: [G; IN_103], +const INPUT_SIZE_104: usize = 3; +const IN_104: usize = 3; +const OUT_104: usize = 1; +fn aiur_fn_104( + inp: [G; IN_104], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_103], ExecError> { +) -> Result<[G; OUT_104], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -8902,8 +8988,8 @@ fn aiur_fn_103( 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_103] = [__v_8]; - record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_104] = [__v_8]; + record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -8917,10 +9003,10 @@ fn aiur_fn_103( let __v_10: G = G::from_bool((__v_9 == G::ZERO)); match __v_10.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_103] = [__v_11]; - record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_104] = [__v_11]; + record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -8937,19 +9023,19 @@ fn aiur_fn_103( let __v_20: G = __loaded[9]; match __v_11.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_103] = [__v_21]; - record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_104] = [__v_21]; + record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_21: G = G::from_u64(0); - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = { let __values: [G; 3] = [__v_21, __v_4, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_103] = [__v_23]; - record.function_queries[103].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_104] = [__v_23]; + record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -8968,15 +9054,15 @@ fn aiur_fn_103( }) } -const INPUT_SIZE_104: usize = 2; -const IN_104: usize = 2; -const OUT_104: usize = 11; -fn aiur_fn_104( - inp: [G; IN_104], +const INPUT_SIZE_105: usize = 2; +const IN_105: usize = 2; +const OUT_105: usize = 11; +fn aiur_fn_105( + inp: [G; IN_105], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_104], ExecError> { +) -> Result<[G; OUT_105], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9005,8 +9091,8 @@ fn aiur_fn_104( let __v_19: G = __r_arr[6]; let __v_20: G = __r_arr[7]; let __v_21: G = G::from_u64(1); - let __ret: [G; OUT_104] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_11, __v_1, __v_21]; - record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_105] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_11, __v_1, __v_21]; + record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -9025,12 +9111,12 @@ fn aiur_fn_104( let __v_21: G = G::from_u64(0); let __v_22: G = G::from_u64(0); let __v_23: G = G::from_u64(0); - let __ret: [G; OUT_104] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23]; - record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_105] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_0, __v_1, __v_23]; + record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -9042,8 +9128,8 @@ fn aiur_fn_104( let __v_23: G = __r_arr[8]; let __v_24: G = __r_arr[9]; let __v_25: G = __r_arr[10]; - let __ret: [G; OUT_104] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; - record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_105] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -9058,15 +9144,15 @@ fn aiur_fn_104( }) } -const INPUT_SIZE_105: usize = 6; -const IN_105: usize = 6; -const OUT_105: usize = 1; -fn aiur_fn_105( - inp: [G; IN_105], +const INPUT_SIZE_106: usize = 6; +const IN_106: usize = 6; +const OUT_106: usize = 1; +fn aiur_fn_106( + inp: [G; IN_106], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_105], ExecError> { +) -> Result<[G; OUT_106], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9074,7 +9160,7 @@ fn aiur_fn_105( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -9256,68 +9342,68 @@ fn aiur_fn_105( let __v_162: G = __r_arr[30]; let __v_163: G = __r_arr[31]; let __v_164: G = { let __values: [G; 34] = [__v_25, __v_5, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_105] = [__v_164]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_164]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_105] = [__v_5]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_5]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_105] = [__v_5]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_5]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_105] = [__v_5]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_5]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_105] = [__v_5]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_5]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_105] = [__v_5]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_5]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_105] = [__v_5]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_5]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_105] = [__v_5]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_5]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __ret: [G; OUT_105] = [__v_5]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_5]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; @@ -9329,7 +9415,7 @@ fn aiur_fn_105( let __v_25: G = __r_arr[8]; let __v_26: G = __r_arr[9]; let __v_27: G = __r_arr[10]; - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = __r_arr[1]; let __v_30: G = __r_arr[2]; @@ -9341,7 +9427,7 @@ fn aiur_fn_105( let __v_36: G = __r_arr[8]; let __v_37: G = __r_arr[9]; let __v_38: G = __r_arr[10]; - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -9353,7 +9439,7 @@ fn aiur_fn_105( let __v_47: G = __r_arr[8]; let __v_48: G = __r_arr[9]; let __v_49: G = __r_arr[10]; - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = __r_arr[2]; @@ -9365,7 +9451,7 @@ fn aiur_fn_105( let __v_58: G = __r_arr[8]; let __v_59: G = __r_arr[9]; let __v_60: G = __r_arr[10]; - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; let __v_62: G = __r_arr[1]; let __v_63: G = __r_arr[2]; @@ -9377,7 +9463,7 @@ fn aiur_fn_105( let __v_69: G = __r_arr[8]; let __v_70: G = __r_arr[9]; let __v_71: G = __r_arr[10]; - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_69, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_69, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_72: G = __r_arr[0]; let __v_73: G = __r_arr[1]; let __v_74: G = __r_arr[2]; @@ -9389,7 +9475,7 @@ fn aiur_fn_105( let __v_80: G = __r_arr[8]; let __v_81: G = __r_arr[9]; let __v_82: G = __r_arr[10]; - let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; let __v_83: G = __r_arr[0]; let __v_84: G = __r_arr[1]; let __v_85: G = __r_arr[2]; @@ -9549,8 +9635,8 @@ fn aiur_fn_105( 1u64 => { let __v_209: G = G::from_u64(0); let __v_210: G = { let __values: [G; 34] = [__v_209, __v_5, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_105] = [__v_210]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_210]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -9611,20 +9697,20 @@ fn aiur_fn_105( let __v_259: G = { let __values: [G; 32] = [__v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_260: G = G::from_u64(0); let __v_261: G = { let __values: [G; 34] = [__v_260, __v_5, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_91, __v_92, __v_241, __v_258, __v_259, __v_261]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_91, __v_92, __v_241, __v_258, __v_259, __v_261]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; let __v_262: G = __r_arr[0]; - let __ret: [G; OUT_105] = [__v_262]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_262]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_209: G = G::from_u64(1); let __v_210: G = (__v_2 + __v_209); let __v_211: G = { let __values: [G; 32] = [__v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_91, __v_92, __v_210, __v_3, __v_211, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_91, __v_92, __v_210, __v_3, __v_211, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; let __v_212: G = __r_arr[0]; - let __ret: [G; OUT_105] = [__v_212]; - record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_106] = [__v_212]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -9635,15 +9721,15 @@ fn aiur_fn_105( }) } -const INPUT_SIZE_106: usize = 1; -const IN_106: usize = 1; -const OUT_106: usize = 32; -fn aiur_fn_106( - inp: [G; IN_106], +const INPUT_SIZE_107: usize = 1; +const IN_107: usize = 1; +const OUT_107: usize = 32; +fn aiur_fn_107( + inp: [G; IN_107], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_106], ExecError> { +) -> Result<[G; OUT_107], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(103); @@ -9695,7 +9781,7 @@ fn aiur_fn_106( let __v_47: G = G::from_u64(1); let __v_48: G = G::from_u64(1); let __v_49: G = { let __values: [G; 34] = [__v_47, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_35, __v_0, __v_36, __v_45, __v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_50.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_51: G = __loaded[0]; @@ -9765,28 +9851,28 @@ fn aiur_fn_106( let __v_114: G = __r_arr[29]; let __v_115: G = __r_arr[30]; let __v_116: G = __r_arr[31]; - let __ret: [G; OUT_106] = [__v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; - record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_107] = [__v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116]; + record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_107: usize = 3; -const IN_107: usize = 3; -const OUT_107: usize = 32; -fn aiur_fn_107( - inp: [G; IN_107], +const INPUT_SIZE_108: usize = 3; +const IN_108: usize = 3; +const OUT_108: usize = 32; +fn aiur_fn_108( + inp: [G; IN_108], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_107], ExecError> { +) -> Result<[G; OUT_108], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[104].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_104] = unsafe { *(result.output.as_ptr() as *const [G; OUT_104]) }; __ret } else { aiur_fn_104(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_106] = unsafe { *(result.output.as_ptr() as *const [G; OUT_106]) }; __ret } else { aiur_fn_106(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -9819,7 +9905,7 @@ fn aiur_fn_107( let __v_33: G = __r_arr[29]; let __v_34: G = __r_arr[30]; let __v_35: G = __r_arr[31]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -9852,21 +9938,21 @@ fn aiur_fn_107( let __v_65: G = __r_arr[29]; let __v_66: G = __r_arr[30]; let __v_67: G = __r_arr[31]; - let __ret: [G; OUT_107] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; - record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_108] = [__v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; + record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_108: usize = 35; -const IN_108: usize = 35; -const OUT_108: usize = 32; -fn aiur_fn_108( - inp: [G; IN_108], +const INPUT_SIZE_109: usize = 35; +const IN_109: usize = 35; +const OUT_109: usize = 32; +fn aiur_fn_109( + inp: [G; IN_109], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_108], ExecError> { +) -> Result<[G; OUT_109], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -9903,16 +9989,16 @@ fn aiur_fn_108( let __v_32: G = inp[32]; let __v_33: G = inp[33]; let __v_34: G = inp[34]; - let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[103].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_103] = unsafe { *(result.output.as_ptr() as *const [G; OUT_103]) }; __ret } else { aiur_fn_103(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; match __v_35.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_108] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; - record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_109] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; let __v_37: G = __r_arr[1]; let __v_38: G = __r_arr[2]; @@ -9945,7 +10031,7 @@ fn aiur_fn_108( let __v_65: G = __r_arr[29]; let __v_66: G = __r_arr[30]; let __v_67: G = __r_arr[31]; - let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; let __v_70: G = __r_arr[2]; @@ -9978,23 +10064,23 @@ fn aiur_fn_108( let __v_97: G = __r_arr[29]; let __v_98: G = __r_arr[30]; let __v_99: G = __r_arr[31]; - let __ret: [G; OUT_108] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99]; - record.function_queries[108].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_109] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_109: usize = 1; -const IN_109: usize = 1; -const OUT_109: usize = 1; -fn aiur_fn_109( - inp: [G; IN_109], +const INPUT_SIZE_110: usize = 1; +const IN_110: usize = 1; +const OUT_110: usize = 1; +fn aiur_fn_110( + inp: [G; IN_110], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_109], ExecError> { +) -> Result<[G; OUT_110], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 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 }; @@ -10004,18 +10090,18 @@ fn aiur_fn_109( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_109] = [__v_4]; - record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_110] = [__v_4]; + record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(2); - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_4 * __v_5); let __v_7: G = (__v_2 + __v_6); - let __ret: [G; OUT_109] = [__v_7]; - record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_110] = [__v_7]; + record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -10025,15 +10111,15 @@ fn aiur_fn_109( }) } -const INPUT_SIZE_110: usize = 37; -const IN_110: usize = 37; -const OUT_110: usize = 33; -fn aiur_fn_110( - inp: [G; IN_110], - record: &mut QueryRecord, - io_buffer: &mut IOBuffer, +const INPUT_SIZE_111: usize = 37; +const IN_111: usize = 37; +const OUT_111: usize = 33; +fn aiur_fn_111( + inp: [G; IN_111], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_110], ExecError> { +) -> Result<[G; OUT_111], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10109,10 +10195,10 @@ fn aiur_fn_110( let __v_70: G = __loaded[33]; match __v_37.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __ret: [G; OUT_110] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_71]; - record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_111] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_71]; + record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -10122,7 +10208,7 @@ fn aiur_fn_110( let __v_73: G = __loaded[2]; match __v_71.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_72, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_72, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_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]; let __cu = unconstrained; if let Some(result) = record.function_queries[102].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_102] = unsafe { *(result.output.as_ptr() as *const [G; OUT_102]) }; __ret } else { aiur_fn_102(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -10155,7 +10241,7 @@ fn aiur_fn_110( let __v_103: G = __r_arr[29]; let __v_104: G = __r_arr[30]; let __v_105: G = __r_arr[31]; - let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_32, __v_33, __v_36, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_32, __v_33, __v_36, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; let __v_106: G = __r_arr[0]; let __v_107: G = __r_arr[1]; let __v_108: G = __r_arr[2]; @@ -10190,7 +10276,7 @@ fn aiur_fn_110( let __v_137: G = __r_arr[31]; let __v_138: G = G::from_u64(1); let __v_139: G = (__v_36 - __v_138); - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_32, __v_33, __v_70, __v_73, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_32, __v_33, __v_70, __v_73, __v_139]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_140: G = __r_arr[0]; let __v_141: G = __r_arr[1]; let __v_142: G = __r_arr[2]; @@ -10224,8 +10310,8 @@ fn aiur_fn_110( let __v_170: G = __r_arr[30]; let __v_171: G = __r_arr[31]; let __v_172: G = __r_arr[32]; - let __ret: [G; OUT_110] = [__v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172]; - record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_111] = [__v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172]; + record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -10240,22 +10326,22 @@ fn aiur_fn_110( }) } -const INPUT_SIZE_111: usize = 5; -const IN_111: usize = 5; -const OUT_111: usize = 33; -fn aiur_fn_111( - inp: [G; IN_111], +const INPUT_SIZE_112: usize = 5; +const IN_112: usize = 5; +const OUT_112: usize = 33; +fn aiur_fn_112( + inp: [G; IN_112], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_111], ExecError> { +) -> Result<[G; OUT_112], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; let __v_3: G = inp[3]; let __v_4: G = inp[4]; - let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -10290,7 +10376,7 @@ fn aiur_fn_111( let __v_36: G = __r_arr[31]; let __v_37: G = G::from_u64(1); let __v_38: G = (__v_4 - __v_37); - let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_0, __v_1, __v_3, __v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_0, __v_1, __v_3, __v_2, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -10324,21 +10410,21 @@ fn aiur_fn_111( let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; let __v_71: G = __r_arr[32]; - let __ret: [G; OUT_111] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; - record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_112] = [__v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_112: usize = 6; -const IN_112: usize = 6; -const OUT_112: usize = 1; -fn aiur_fn_112( - inp: [G; IN_112], +const INPUT_SIZE_113: usize = 6; +const IN_113: usize = 6; +const OUT_113: usize = 1; +fn aiur_fn_113( + inp: [G; IN_113], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_112], ExecError> { +) -> Result<[G; OUT_113], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10346,7 +10432,7 @@ fn aiur_fn_112( let __v_3: G = inp[3]; let __v_4: G = inp[4]; let __v_5: G = inp[5]; - let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_111] = unsafe { *(result.output.as_ptr() as *const [G; OUT_111]) }; __ret } else { aiur_fn_111(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = __r_arr[2]; @@ -10380,7 +10466,7 @@ fn aiur_fn_112( let __v_36: G = __r_arr[30]; let __v_37: G = __r_arr[31]; let __v_38: G = __r_arr[32]; - let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -10413,23 +10499,23 @@ fn aiur_fn_112( let __v_68: G = __r_arr[29]; let __v_69: G = __r_arr[30]; let __v_70: G = __r_arr[31]; - let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__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_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_100] = unsafe { *(result.output.as_ptr() as *const [G; OUT_100]) }; __ret } else { aiur_fn_100(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__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_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; - let __ret: [G; OUT_112] = [__v_71]; - record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_113] = [__v_71]; + record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_113: usize = 2; -const IN_113: usize = 2; -const OUT_113: usize = 1; -fn aiur_fn_113( - inp: [G; IN_113], +const INPUT_SIZE_114: usize = 2; +const IN_114: usize = 2; +const OUT_114: usize = 1; +fn aiur_fn_114( + inp: [G; IN_114], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_113], ExecError> { +) -> Result<[G; OUT_114], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10439,17 +10525,17 @@ fn aiur_fn_113( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_113] = [__v_1]; - record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_114] = [__v_1]; + record.function_queries[114].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_113] = { let __args: [G; IN_113] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_113] = [__v_7]; - record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_114] = [__v_7]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -10459,15 +10545,15 @@ fn aiur_fn_113( }) } -const INPUT_SIZE_114: usize = 2; -const IN_114: usize = 2; -const OUT_114: usize = 1; -fn aiur_fn_114( - inp: [G; IN_114], +const INPUT_SIZE_115: usize = 2; +const IN_115: usize = 2; +const OUT_115: usize = 1; +fn aiur_fn_115( + inp: [G; IN_115], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_114], ExecError> { +) -> Result<[G; OUT_115], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10478,26 +10564,26 @@ fn aiur_fn_114( match __v_2.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(1); - let __ret: [G; OUT_114] = [__v_5]; - record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_115] = [__v_5]; + record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_15] = { let __args: [G; IN_15] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[15].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_15] = unsafe { *(result.output.as_ptr() as *const [G; OUT_15]) }; __ret } else { aiur_fn_15(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_114] = [__v_6]; - record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_115] = [__v_6]; + record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __ret: [G; OUT_114] = [__v_7]; - record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_115] = [__v_7]; + record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -10509,15 +10595,15 @@ fn aiur_fn_114( }) } -const INPUT_SIZE_115: usize = 8; -const IN_115: usize = 8; -const OUT_115: usize = 2; -fn aiur_fn_115( - inp: [G; IN_115], +const INPUT_SIZE_116: usize = 8; +const IN_116: usize = 8; +const OUT_116: usize = 2; +fn aiur_fn_116( + inp: [G; IN_116], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_115], ExecError> { +) -> Result<[G; OUT_116], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10529,14 +10615,14 @@ fn aiur_fn_115( let __v_7: G = inp[7]; let __v_8: G = G::from_u64(1); let __v_9: G = (__v_1 + __v_8); - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_15, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_13] = unsafe { *(result.output.as_ptr() as *const [G; OUT_13]) }; __ret } else { aiur_fn_13(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; @@ -10561,51 +10647,51 @@ fn aiur_fn_115( let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_21, __v_22, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; - let __ret: [G; OUT_115] = [__v_30, __v_31]; - record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_116] = [__v_30, __v_31]; + record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_116: usize = 2; -const IN_116: usize = 2; -const OUT_116: usize = 1; -fn aiur_fn_116( - inp: [G; IN_116], +const INPUT_SIZE_117: usize = 2; +const IN_117: usize = 2; +const OUT_117: usize = 1; +fn aiur_fn_117( + inp: [G; IN_117], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_116], ExecError> { +) -> Result<[G; OUT_117], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_u64(7); - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; - let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_116] = [__v_9]; - record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_117] = [__v_9]; + record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_117: usize = 1; -const IN_117: usize = 1; -const OUT_117: usize = 1; -fn aiur_fn_117( - inp: [G; IN_117], +const INPUT_SIZE_118: usize = 1; +const IN_118: usize = 1; +const OUT_118: usize = 1; +fn aiur_fn_118( + inp: [G; IN_118], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_117], ExecError> { +) -> Result<[G; OUT_118], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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 }; @@ -10624,19 +10710,19 @@ fn aiur_fn_117( 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_117] = [__v_13]; - record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_118] = [__v_13]; + record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_11: G = G::from_u64(0); let __r_arr: [G; OUT_10] = { let __args: [G; IN_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[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __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 !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 __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_117] = [__v_14]; - record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_118] = [__v_14]; + record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -10646,15 +10732,15 @@ fn aiur_fn_117( }) } -const INPUT_SIZE_118: usize = 10; -const IN_118: usize = 10; -const OUT_118: usize = 4; -fn aiur_fn_118( - inp: [G; IN_118], +const INPUT_SIZE_119: usize = 10; +const IN_119: usize = 10; +const OUT_119: usize = 4; +fn aiur_fn_119( + inp: [G; IN_119], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_118], ExecError> { +) -> Result<[G; OUT_119], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10672,8 +10758,8 @@ fn aiur_fn_118( let __v_12: G = __loaded[2]; match __v_10.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_118] = [__v_6, __v_7, __v_8, __v_9]; - record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_119] = [__v_6, __v_7, __v_8, __v_9]; + record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -10700,13 +10786,13 @@ fn aiur_fn_118( let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_8, __v_9, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_12, __v_16, __v_2, __v_3, __v_4, __v_5, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_12, __v_16, __v_2, __v_3, __v_4, __v_5, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_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 __ret: [G; OUT_118] = [__v_28, __v_29, __v_30, __v_31]; - record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_119] = [__v_28, __v_29, __v_30, __v_31]; + record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -10721,15 +10807,15 @@ fn aiur_fn_118( }) } -const INPUT_SIZE_119: usize = 2; -const IN_119: usize = 2; -const OUT_119: usize = 1; -fn aiur_fn_119( - inp: [G; IN_119], +const INPUT_SIZE_120: usize = 2; +const IN_120: usize = 2; +const OUT_120: usize = 1; +fn aiur_fn_120( + inp: [G; IN_120], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_119], ExecError> { +) -> Result<[G; OUT_120], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10740,8 +10826,8 @@ fn aiur_fn_119( let __v_5: G = __loaded[3]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_119] = [__v_1]; - record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_120] = [__v_1]; + record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -10763,14 +10849,14 @@ fn aiur_fn_119( let __v_19: G = __r_arr[5]; let __v_20: G = __r_arr[6]; let __v_21: G = __r_arr[7]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !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_22: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; - let __ret: [G; OUT_119] = [__v_24]; - record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_120] = [__v_24]; + record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -10780,15 +10866,15 @@ fn aiur_fn_119( }) } -const INPUT_SIZE_120: usize = 2; -const IN_120: usize = 2; -const OUT_120: usize = 1; -fn aiur_fn_120( - inp: [G; IN_120], +const INPUT_SIZE_121: usize = 2; +const IN_121: usize = 2; +const OUT_121: usize = 1; +fn aiur_fn_121( + inp: [G; IN_121], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_120], ExecError> { +) -> Result<[G; OUT_121], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10798,17 +10884,17 @@ fn aiur_fn_120( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_120] = [__v_1]; - record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_121] = [__v_1]; + record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_120] = [__v_6]; - record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_121] = [__v_6]; + record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -10818,15 +10904,15 @@ fn aiur_fn_120( }) } -const INPUT_SIZE_121: usize = 2; -const IN_121: usize = 2; -const OUT_121: usize = 1; -fn aiur_fn_121( - inp: [G; IN_121], +const INPUT_SIZE_122: usize = 2; +const IN_122: usize = 2; +const OUT_122: usize = 1; +fn aiur_fn_122( + inp: [G; IN_122], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_121], ExecError> { +) -> Result<[G; OUT_122], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10836,17 +10922,17 @@ fn aiur_fn_121( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_121] = [__v_1]; - record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_122] = [__v_1]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_121] = [__v_6]; - record.function_queries[121].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_122] = [__v_6]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -10856,30 +10942,30 @@ fn aiur_fn_121( }) } -const INPUT_SIZE_122: usize = 3; -const IN_122: usize = 3; -const OUT_122: usize = 1; -fn aiur_fn_122( - inp: [G; IN_122], +const INPUT_SIZE_123: usize = 3; +const IN_123: usize = 3; +const OUT_123: usize = 1; +fn aiur_fn_123( + inp: [G; IN_123], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_122], ExecError> { +) -> Result<[G; OUT_123], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_122] = [__v_2]; - record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_123] = [__v_2]; + record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; - let __ret: [G; OUT_122] = [__v_3]; - record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_123] = [__v_3]; + record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -10889,15 +10975,15 @@ fn aiur_fn_122( }) } -const INPUT_SIZE_123: usize = 2; -const IN_123: usize = 2; -const OUT_123: usize = 1; -fn aiur_fn_123( - inp: [G; IN_123], +const INPUT_SIZE_124: usize = 2; +const IN_124: usize = 2; +const OUT_124: usize = 1; +fn aiur_fn_124( + inp: [G; IN_124], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_123], ExecError> { +) -> Result<[G; OUT_124], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10907,8 +10993,8 @@ fn aiur_fn_123( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_123] = [__v_0]; - record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_124] = [__v_0]; + record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -10920,12 +11006,12 @@ fn aiur_fn_123( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_123] = [__v_14]; - record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_124] = [__v_14]; + record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -10935,15 +11021,15 @@ fn aiur_fn_123( }) } -const INPUT_SIZE_124: usize = 10; -const IN_124: usize = 10; -const OUT_124: usize = 2; -fn aiur_fn_124( - inp: [G; IN_124], +const INPUT_SIZE_125: usize = 10; +const IN_125: usize = 10; +const OUT_125: usize = 2; +fn aiur_fn_125( + inp: [G; IN_125], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_124], ExecError> { +) -> Result<[G; OUT_125], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -10960,43 +11046,43 @@ fn aiur_fn_124( 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_124] = [__v_0, __v_12]; - record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_125] = [__v_0, __v_12]; + record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__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[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__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[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = G::from_u64(1); let __v_12: G = G::from_u64(1); let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_10, __v_13, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; - let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); } - let __ret: [G; OUT_124] = [__v_15, __v_16]; - record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_125] = [__v_15, __v_16]; + record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_125: usize = 4; -const IN_125: usize = 4; -const OUT_125: usize = 2; -fn aiur_fn_125( - inp: [G; IN_125], +const INPUT_SIZE_126: usize = 4; +const IN_126: usize = 4; +const OUT_126: usize = 2; +fn aiur_fn_126( + inp: [G; IN_126], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_125], ExecError> { +) -> Result<[G; OUT_126], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11011,8 +11097,8 @@ fn aiur_fn_125( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_125] = [__v_9, __v_0]; - record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_126] = [__v_9, __v_0]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -11029,12 +11115,12 @@ fn aiur_fn_125( let __v_16: G = __loaded[9]; match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_17, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; @@ -11053,7 +11139,7 @@ fn aiur_fn_125( let __v_35: G = __r_arr[15]; let __v_36: G = __r_arr[16]; let __v_37: G = __r_arr[17]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_36, __v_6, __v_16, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; let __v_39: G = __r_arr[1]; let __v_40: G = G::from_u64(0); @@ -11062,8 +11148,8 @@ fn aiur_fn_125( let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __v_43: G = { let __values: [G; 4] = [__v_40, __v_41, __v_42, __v_38]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_125] = [__v_43, __v_39]; - record.function_queries[125].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_126] = [__v_43, __v_39]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -11078,15 +11164,15 @@ fn aiur_fn_125( }) } -const INPUT_SIZE_126: usize = 5; -const IN_126: usize = 5; -const OUT_126: usize = 1; -fn aiur_fn_126( - inp: [G; IN_126], +const INPUT_SIZE_127: usize = 5; +const IN_127: usize = 5; +const OUT_127: usize = 1; +fn aiur_fn_127( + inp: [G; IN_127], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_126], ExecError> { +) -> Result<[G; OUT_127], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11096,12 +11182,12 @@ fn aiur_fn_126( match __v_2.as_canonical_u64() { 0u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_126] = [__v_5]; - record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_127] = [__v_5]; + record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_1 - __v_4); let __v_7: G = (__v_5 + __v_6); @@ -11109,8 +11195,8 @@ fn aiur_fn_126( match __v_8.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_126] = [__v_9]; - record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_127] = [__v_9]; + record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -11118,10 +11204,10 @@ fn aiur_fn_126( let __v_10: G = (__v_2 - __v_9); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 + __v_11); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_10, __v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_126] = [__v_13]; - record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_127] = [__v_13]; + record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -11130,15 +11216,15 @@ fn aiur_fn_126( }) } -const INPUT_SIZE_127: usize = 4; -const IN_127: usize = 4; -const OUT_127: usize = 1; -fn aiur_fn_127( - inp: [G; IN_127], +const INPUT_SIZE_128: usize = 4; +const IN_128: usize = 4; +const OUT_128: usize = 1; +fn aiur_fn_128( + inp: [G; IN_128], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_127], ExecError> { +) -> Result<[G; OUT_128], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11149,22 +11235,22 @@ fn aiur_fn_127( let __v_4: G = G::from_u64(1); let __v_5: G = G::from_u64(1); let __v_6: G = { let __values: [G; 7] = [__v_4, __v_5, __v_5, __v_5, __v_5, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_127] = [__v_6]; - record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_128] = [__v_6]; + record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; match __v_5.as_canonical_u64() { 0u64 => { let __v_6: G = G::from_u64(1); let __v_7: G = (__v_3 - __v_6); - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_127] = [__v_8]; - record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_128] = [__v_8]; + record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -11175,11 +11261,11 @@ fn aiur_fn_127( let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(1); let __v_12: G = (__v_3 - __v_11); - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 7] = [__v_6, __v_3, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_127] = [__v_14]; - record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_128] = [__v_14]; + record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -11188,15 +11274,15 @@ fn aiur_fn_127( }) } -const INPUT_SIZE_128: usize = 8; -const IN_128: usize = 8; -const OUT_128: usize = 1; -fn aiur_fn_128( - inp: [G; IN_128], +const INPUT_SIZE_129: usize = 8; +const IN_129: usize = 8; +const OUT_129: usize = 1; +fn aiur_fn_129( + inp: [G; IN_129], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_128], ExecError> { +) -> Result<[G; OUT_129], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11219,8 +11305,8 @@ fn aiur_fn_128( let __v_15: G = G::from_u64(1); let __v_16: G = G::from_u64(1); let __v_17: G = { let __values: [G; 7] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_128] = [__v_17]; - record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_129] = [__v_17]; + record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -11230,24 +11316,24 @@ fn aiur_fn_128( let __v_16: G = G::from_bool((__v_15 == G::ZERO)); match __v_16.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_12, __v_13, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_12, __v_13, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; let __v_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 = G::from_u64(0); let __v_22: G = { let __values: [G; 7] = [__v_21, __v_9, __v_19, __v_20, __v_17, __v_18, __v_14]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_128] = [__v_22]; - record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_129] = [__v_22]; + record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_17: G = G::from_u64(0); - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_14, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = { let __values: [G; 7] = [__v_17, __v_9, __v_10, __v_11, __v_12, __v_13, __v_18]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_128] = [__v_19]; - record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_129] = [__v_19]; + record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -11261,15 +11347,15 @@ fn aiur_fn_128( }) } -const INPUT_SIZE_129: usize = 2; -const IN_129: usize = 2; -const OUT_129: usize = 1; -fn aiur_fn_129( - inp: [G; IN_129], +const INPUT_SIZE_130: usize = 2; +const IN_130: usize = 2; +const OUT_130: usize = 1; +fn aiur_fn_130( + inp: [G; IN_130], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_129], ExecError> { +) -> Result<[G; OUT_130], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11284,8 +11370,8 @@ fn aiur_fn_129( match __v_2.as_canonical_u64() { 1u64 => { let __v_9: G = G::from_u64(1); - let __ret: [G; OUT_129] = [__v_9]; - record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_130] = [__v_9]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -11304,15 +11390,15 @@ fn aiur_fn_129( return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64() }); } let __v_15: G = G::from_u64(1); - let __ret: [G; OUT_129] = [__v_15]; - record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_130] = [__v_15]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_129] = [__v_11]; - record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_130] = [__v_11]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -11326,29 +11412,29 @@ fn aiur_fn_129( }) } -const INPUT_SIZE_130: usize = 2; -const IN_130: usize = 2; -const OUT_130: usize = 1; -fn aiur_fn_130( - inp: [G; IN_130], +const INPUT_SIZE_131: usize = 2; +const IN_131: usize = 2; +const OUT_131: usize = 1; +fn aiur_fn_131( + inp: [G; IN_131], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_130], ExecError> { +) -> Result<[G; OUT_131], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_0.as_canonical_u64() { 0u64 => { let __v_2: G = G::from_u64(0); - let __ret: [G; OUT_130] = [__v_2]; - record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_131] = [__v_2]; + record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_2: G = G::from_u64(1); - let __ret: [G; OUT_130] = [__v_2]; - record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_131] = [__v_2]; + record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -11358,15 +11444,15 @@ fn aiur_fn_130( }) } -const INPUT_SIZE_131: usize = 10; -const IN_131: usize = 10; -const OUT_131: usize = 1; -fn aiur_fn_131( - inp: [G; IN_131], +const INPUT_SIZE_132: usize = 10; +const IN_132: usize = 10; +const OUT_132: usize = 1; +fn aiur_fn_132( + inp: [G; IN_132], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_131], ExecError> { +) -> Result<[G; OUT_132], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11379,9 +11465,9 @@ fn aiur_fn_131( let __v_8: G = inp[8]; let __v_9: G = inp[9]; let __v_10: G = (__v_3 - __v_1); - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(0); let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_4, __v_5, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; @@ -11390,9 +11476,9 @@ fn aiur_fn_131( let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = (__v_18 - __v_19); let __v_21: G = G::from_bool((__v_20 == G::ZERO)); @@ -11400,23 +11486,23 @@ fn aiur_fn_131( if (__v_21 != __v_22) { return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64() }); } - let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1, __v_6, __v_7, __v_16, __v_17, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_1, __v_6, __v_7, __v_16, __v_17, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; - let __ret: [G; OUT_131] = [__v_23]; - record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_132] = [__v_23]; + record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_132: usize = 11; -const IN_132: usize = 11; -const OUT_132: usize = 1; -fn aiur_fn_132( - inp: [G; IN_132], +const INPUT_SIZE_133: usize = 11; +const IN_133: usize = 11; +const OUT_133: usize = 1; +fn aiur_fn_133( + inp: [G; IN_133], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_132], ExecError> { +) -> Result<[G; OUT_133], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11430,36 +11516,36 @@ fn aiur_fn_132( let __v_9: G = inp[9]; let __v_10: G = inp[10]; let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = G::from_u64(1); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = G::from_u64(0); let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_5, __v_6, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_3, __v_1, __v_2, __v_5, __v_6, __v_7, __v_12, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_19, __v_3, __v_1, __v_2, __v_17, __v_18, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_19, __v_3, __v_1, __v_2, __v_17, __v_18, __v_7, __v_14, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __ret: [G; OUT_132] = [__v_20]; - record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_133] = [__v_20]; + record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_133: usize = 13; -const IN_133: usize = 13; -const OUT_133: usize = 1; -fn aiur_fn_133( - inp: [G; IN_133], +const INPUT_SIZE_134: usize = 13; +const IN_134: usize = 13; +const OUT_134: usize = 1; +fn aiur_fn_134( + inp: [G; IN_134], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_133], ExecError> { +) -> Result<[G; OUT_134], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11476,45 +11562,45 @@ fn aiur_fn_133( let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_133] = [__v_0]; - record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_134] = [__v_0]; + record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_16, __v_17, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_2, __v_14, __v_13, __v_7, __v_8, __v_16, __v_17, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = (__v_4 + __v_19); let __v_21: G = G::from_u64(1); let __v_22: G = (__v_5 - __v_21); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_18, __v_1, __v_2, __v_3, __v_20, __v_22, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_18, __v_1, __v_2, __v_3, __v_20, __v_22, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !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_23: G = __r_arr[0]; - let __ret: [G; OUT_133] = [__v_23]; - record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_134] = [__v_23]; + record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_134: usize = 13; -const IN_134: usize = 13; -const OUT_134: usize = 1; -fn aiur_fn_134( - inp: [G; IN_134], +const INPUT_SIZE_135: usize = 13; +const IN_135: usize = 13; +const OUT_135: usize = 1; +fn aiur_fn_135( + inp: [G; IN_135], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_134], ExecError> { +) -> Result<[G; OUT_135], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11531,48 +11617,48 @@ fn aiur_fn_134( let __v_12: G = inp[12]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_134] = [__v_0]; - record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_135] = [__v_0]; + record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = (__v_13 + __v_3); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_9, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_10, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_16, __v_19, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_131] = unsafe { *(result.output.as_ptr() as *const [G; OUT_131]) }; __ret } else { aiur_fn_131(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_14, __v_1, __v_2, __v_7, __v_8, __v_16, __v_19, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = G::from_u64(1); let __v_22: G = (__v_4 + __v_21); let __v_23: G = G::from_u64(1); let __v_24: G = (__v_5 - __v_23); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_20, __v_1, __v_2, __v_3, __v_22, __v_24, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_20, __v_1, __v_2, __v_3, __v_22, __v_24, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; - let __ret: [G; OUT_134] = [__v_25]; - record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_135] = [__v_25]; + record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_135: usize = 15; -const IN_135: usize = 15; -const OUT_135: usize = 1; -fn aiur_fn_135( - inp: [G; IN_135], +const INPUT_SIZE_136: usize = 15; +const IN_136: usize = 15; +const OUT_136: usize = 1; +fn aiur_fn_136( + inp: [G; IN_136], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_135], ExecError> { +) -> Result<[G; OUT_136], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11591,12 +11677,12 @@ fn aiur_fn_135( let __v_14: G = inp[14]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_135] = [__v_0]; - record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_136] = [__v_0]; + record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_8, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; match __v_15.as_canonical_u64() { @@ -11605,23 +11691,23 @@ fn aiur_fn_135( let __v_18: G = (__v_4 + __v_17); let __v_19: G = G::from_u64(1); let __v_20: G = (__v_5 - __v_19); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_3, __v_18, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __ret: [G; OUT_135] = [__v_21]; - record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_136] = [__v_21]; + record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = (__v_17 + __v_3); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_11, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_118] = unsafe { *(result.output.as_ptr() as *const [G; OUT_118]) }; __ret } else { aiur_fn_118(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !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_21: G = __r_arr[0]; - let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_20, __v_21, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_0, __v_1, __v_2, __v_18, __v_17, __v_9, __v_10, __v_20, __v_21, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = G::from_u64(1); let __v_24: G = (__v_4 + __v_23); @@ -11629,10 +11715,10 @@ fn aiur_fn_135( let __v_26: G = (__v_5 - __v_25); let __v_27: G = G::from_u64(1); let __v_28: G = (__v_6 + __v_27); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_22, __v_1, __v_2, __v_3, __v_24, __v_26, __v_28, __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[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_22, __v_1, __v_2, __v_3, __v_24, __v_26, __v_28, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __ret: [G; OUT_135] = [__v_29]; - record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_136] = [__v_29]; + record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -11644,15 +11730,15 @@ fn aiur_fn_135( }) } -const INPUT_SIZE_136: usize = 15; -const IN_136: usize = 15; -const OUT_136: usize = 1; -fn aiur_fn_136( - inp: [G; IN_136], +const INPUT_SIZE_137: usize = 15; +const IN_137: usize = 15; +const OUT_137: usize = 1; +fn aiur_fn_137( + inp: [G; IN_137], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_136], ExecError> { +) -> Result<[G; OUT_137], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11671,25 +11757,25 @@ fn aiur_fn_136( let __v_14: G = inp[14]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_136] = [__v_0]; - record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_137] = [__v_0]; + record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_15: G = G::from_u64(3); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; match __v_16.as_canonical_u64() { _ => { let __v_18: G = G::from_u64(0); - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_6, __v_10, __v_5, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_6, __v_10, __v_5, __v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = (__v_21 - __v_22); let __v_24: G = G::from_bool((__v_23 == G::ZERO)); @@ -11698,9 +11784,9 @@ fn aiur_fn_136( return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64() }); } let __v_26: G = (__v_9 - __v_20); - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2, __v_16, __v_19, __v_27, __v_17, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_2, __v_16, __v_19, __v_27, __v_17, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; let __v_29: G = G::from_u64(1); if (__v_28 != __v_29) { @@ -11708,10 +11794,10 @@ fn aiur_fn_136( } let __v_30: G = G::from_u64(0); let __v_31: G = G::from_u64(0); - let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_8, __v_9, __v_10, __v_30, __v_7, __v_31, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_8, __v_9, __v_10, __v_30, __v_7, __v_31, __v_6, __v_5, __v_11, __v_12, __v_16, __v_4, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __ret: [G; OUT_136] = [__v_32]; - record.function_queries[136].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_137] = [__v_32]; + record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -11723,15 +11809,15 @@ fn aiur_fn_136( }) } -const INPUT_SIZE_137: usize = 4; -const IN_137: usize = 4; -const OUT_137: usize = 1; -fn aiur_fn_137( - inp: [G; IN_137], +const INPUT_SIZE_138: usize = 4; +const IN_138: usize = 4; +const OUT_138: usize = 1; +fn aiur_fn_138( + inp: [G; IN_138], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_137], ExecError> { +) -> Result<[G; OUT_138], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11742,39 +11828,39 @@ fn aiur_fn_137( 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_137] = [__v_6]; - record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_138] = [__v_6]; + record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_4: G = G::from_u64(0); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = (__v_5 + __v_1); let __v_7: G = G::from_u64(1); let __v_8: G = (__v_2 - __v_7); let __v_9: G = G::from_u64(1); let __v_10: G = (__v_3 + __v_9); - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_0, __v_1, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = { let __values: [G; 3] = [__v_4, __v_6, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_137] = [__v_12]; - record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_138] = [__v_12]; + record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_138: usize = 1; -const IN_138: usize = 1; -const OUT_138: usize = 1; -fn aiur_fn_138( - inp: [G; IN_138], +const INPUT_SIZE_139: usize = 1; +const IN_139: usize = 1; +const OUT_139: usize = 1; +fn aiur_fn_139( + inp: [G; IN_139], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_138], ExecError> { +) -> Result<[G; OUT_139], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; @@ -11784,23 +11870,23 @@ fn aiur_fn_138( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_138] = [__v_4]; - record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_139] = [__v_4]; + record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_138] = [__v_4]; - record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_139] = [__v_4]; + record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_138] = [__v_2]; - record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_139] = [__v_2]; + record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -11812,15 +11898,15 @@ fn aiur_fn_138( }) } -const INPUT_SIZE_139: usize = 5; -const IN_139: usize = 5; -const OUT_139: usize = 1; -fn aiur_fn_139( - inp: [G; IN_139], +const INPUT_SIZE_140: usize = 5; +const IN_140: usize = 5; +const OUT_140: usize = 1; +fn aiur_fn_140( + inp: [G; IN_140], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_139], ExecError> { +) -> Result<[G; OUT_140], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11832,12 +11918,12 @@ fn aiur_fn_139( 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_139] = [__v_7]; - record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_140] = [__v_7]; + record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; match __v_5.as_canonical_u64() { @@ -11846,26 +11932,26 @@ fn aiur_fn_139( 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_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_139] = [__v_11]; - record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_140] = [__v_11]; + record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_7: G = G::from_u64(0); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = (__v_8 + __v_1); let __v_10: G = G::from_u64(1); let __v_11: G = (__v_3 - __v_10); let __v_12: G = G::from_u64(1); let __v_13: G = (__v_4 + __v_12); - let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = { let __values: [G; 3] = [__v_7, __v_9, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_139] = [__v_15]; - record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_140] = [__v_15]; + record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -11877,15 +11963,15 @@ fn aiur_fn_139( }) } -const INPUT_SIZE_140: usize = 5; -const IN_140: usize = 5; -const OUT_140: usize = 4; -fn aiur_fn_140( - inp: [G; IN_140], +const INPUT_SIZE_141: usize = 5; +const IN_141: usize = 5; +const OUT_141: usize = 4; +fn aiur_fn_141( + inp: [G; IN_141], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_140], ExecError> { +) -> Result<[G; OUT_141], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11894,28 +11980,28 @@ fn aiur_fn_140( let __v_4: G = inp[4]; match __v_0.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_140] = [__v_1, __v_2, __v_3, __v_4]; - record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_141] = [__v_1, __v_2, __v_3, __v_4]; + record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_140] = [__v_3, __v_4, __v_1, __v_2]; - record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_141] = [__v_3, __v_4, __v_1, __v_2]; + record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_141: usize = 4; -const IN_141: usize = 4; -const OUT_141: usize = 1; -fn aiur_fn_141( - inp: [G; IN_141], +const INPUT_SIZE_142: usize = 4; +const IN_142: usize = 4; +const OUT_142: usize = 1; +fn aiur_fn_142( + inp: [G; IN_142], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_141], ExecError> { +) -> Result<[G; OUT_142], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -11968,21 +12054,21 @@ fn aiur_fn_141( let __v_44: G = { let __values: [G; 10] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_43]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_45: G = { let __values: [G; 10] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_44]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_46: G = { let __values: [G; 10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_141] = [__v_46]; - record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_142] = [__v_46]; + record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_142: usize = 6; -const IN_142: usize = 6; -const OUT_142: usize = 3; -fn aiur_fn_142( - inp: [G; IN_142], +const INPUT_SIZE_143: usize = 6; +const IN_143: usize = 6; +const OUT_143: usize = 3; +fn aiur_fn_143( + inp: [G; IN_143], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_142], ExecError> { +) -> Result<[G; OUT_143], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12000,8 +12086,8 @@ fn aiur_fn_142( let __v_12: G = __loaded[6]; match __v_6.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_142] = [__v_0, __v_1, __v_5]; - record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_143] = [__v_0, __v_1, __v_5]; + record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -12012,7 +12098,7 @@ fn aiur_fn_142( match __v_14.as_canonical_u64() { 1u64 => { let __v_15: G = G::from_u64(1); - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_3, __v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_16, __v_17, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; @@ -12021,13 +12107,13 @@ fn aiur_fn_142( let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0, __v_1, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; - let __ret: [G; OUT_142] = [__v_20, __v_21, __v_12]; - record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_143] = [__v_20, __v_21, __v_12]; + record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __ret: [G; OUT_142] = [__v_0, __v_1, __v_5]; - record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_143] = [__v_0, __v_1, __v_5]; + record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -12041,15 +12127,15 @@ fn aiur_fn_142( }) } -const INPUT_SIZE_143: usize = 9; -const IN_143: usize = 9; -const OUT_143: usize = 2; -fn aiur_fn_143( - inp: [G; IN_143], +const INPUT_SIZE_144: usize = 9; +const IN_144: usize = 9; +const OUT_144: usize = 2; +fn aiur_fn_144( + inp: [G; IN_144], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_143], ExecError> { +) -> Result<[G; OUT_144], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12074,14 +12160,14 @@ fn aiur_fn_143( if (__v_15 != __v_16) { return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); } - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !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_17: G = __r_arr[0]; let __v_18: G = G::from_u64(0); if (__v_17 != __v_18) { return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); } - let __ret: [G; OUT_143] = [__v_0, __v_1]; - record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_144] = [__v_0, __v_1]; + record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -12109,29 +12195,29 @@ fn aiur_fn_143( let __v_24: G = G::from_u64(1); let __v_25: G = (__v_6 - __v_24); let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_11, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_11, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; - let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_22, __v_0, __v_1, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_22, __v_0, __v_1, __v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; let __v_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_115] = { let __args: [G; IN_115] = [__v_23, __v_25, __v_15, __v_16, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_23, __v_25, __v_15, __v_16, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; let __v_34: G = __r_arr[1]; - let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_33, __v_34, __v_25, __v_15, __v_16, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_33, __v_34, __v_25, __v_15, __v_16, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = __r_arr[1]; let __v_37: G = __r_arr[2]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !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_38: G = __r_arr[0]; let __v_39: G = G::from_u64(1); if (__v_38 != __v_39) { return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_39.as_canonical_u64() }); } let __v_40: G = G::from_u64(0); - let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_142] = unsafe { *(result.output.as_ptr() as *const [G; OUT_142]) }; __ret } else { aiur_fn_142(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); @@ -12142,17 +12228,17 @@ fn aiur_fn_143( let __v_48: G = G::from_u64(1); let __v_49: G = { let __values: [G; 3] = [__v_47, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_50: G = { let __values: [G; 3] = [__v_46, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_19, __v_45, __v_50, __v_23, __v_12, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_19, __v_45, __v_50, __v_23, __v_12, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_51: G = __r_arr[0]; let __v_52: G = G::from_u64(1); if (__v_51 != __v_52) { return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_52.as_canonical_u64() }); } - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_35, __v_36, __v_17, __v_20, __v_13, __v_23, __v_25, __v_37, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_35, __v_36, __v_17, __v_20, __v_13, __v_23, __v_25, __v_37, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; let __v_54: G = __r_arr[1]; - let __ret: [G; OUT_143] = [__v_53, __v_54]; - record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_144] = [__v_53, __v_54]; + record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -12179,15 +12265,15 @@ fn aiur_fn_143( }) } -const INPUT_SIZE_144: usize = 25; -const IN_144: usize = 25; -const OUT_144: usize = 1; -fn aiur_fn_144( - inp: [G; IN_144], +const INPUT_SIZE_145: usize = 25; +const IN_145: usize = 25; +const OUT_145: usize = 1; +fn aiur_fn_145( + inp: [G; IN_145], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_144], ExecError> { +) -> Result<[G; OUT_145], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12216,38 +12302,38 @@ fn aiur_fn_144( let __v_24: G = inp[24]; match __v_1.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_15, __v_19, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_128] = unsafe { *(result.output.as_ptr() as *const [G; OUT_128]) }; __ret } else { aiur_fn_128(__args, record, io_buffer, __cu)? } }; let __v_25: G = __r_arr[0]; let __v_26: G = G::from_u64(0); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; let __v_28: G = __r_arr[1]; match __v_27.as_canonical_u64() { _ => { let __v_29: G = G::from_u64(0); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_25, __v_0, __v_20, __v_19, __v_29, __v_18, __v_15, __v_16, __v_17, __v_27, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_25, __v_0, __v_20, __v_19, __v_29, __v_18, __v_15, __v_16, __v_17, __v_27, __v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_30: G = __r_arr[0]; let __v_31: G = G::from_u64(1); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; match __v_32.as_canonical_u64() { _ => { let __v_34: G = G::from_u64(0); - let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_30, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_32, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_133] = unsafe { *(result.output.as_ptr() as *const [G; OUT_133]) }; __ret } else { aiur_fn_133(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_30, __v_0, __v_20, __v_19, __v_34, __v_18, __v_15, __v_16, __v_17, __v_32, __v_6, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; let __v_36: G = G::from_u64(2); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; let __v_38: G = __r_arr[1]; match __v_37.as_canonical_u64() { _ => { let __v_39: G = G::from_u64(0); - let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_35, __v_0, __v_20, __v_19, __v_39, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_35, __v_0, __v_20, __v_19, __v_39, __v_18, __v_15, __v_16, __v_17, __v_37, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_40, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_40, __v_1, __v_13, __v_8, __v_9, __v_14, __v_15, __v_18, __v_0, __v_20, __v_19, __v_16, __v_17, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_41, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_129] = unsafe { *(result.output.as_ptr() as *const [G; OUT_129]) }; __ret } else { aiur_fn_129(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_41, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; let __v_42: G = __r_arr[0]; let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_41.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; let __v_43: G = __loaded[0]; @@ -12261,10 +12347,10 @@ fn aiur_fn_144( 0u64 => { match __v_44.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_47, __v_48, __v_21, __v_22, __v_2, __v_0, __v_20, __v_49, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_143] = unsafe { *(result.output.as_ptr() as *const [G; OUT_143]) }; __ret } else { aiur_fn_143(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_47, __v_48, __v_21, __v_22, __v_2, __v_0, __v_20, __v_49, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = (__v_52 - __v_24); let __v_54: G = G::from_bool((__v_53 == G::ZERO)); @@ -12272,10 +12358,10 @@ fn aiur_fn_144( if (__v_54 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64() }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !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_56: G = __r_arr[0]; let __v_57: G = G::from_u64(3); - let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { if !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_58: G = __r_arr[0]; let __v_59: G = (__v_57 + __v_58); let __v_60: G = (__v_56 - __v_59); @@ -12284,7 +12370,7 @@ fn aiur_fn_144( if (__v_61 != __v_62) { return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_62.as_canonical_u64() }); } - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = (__v_63 - __v_18); let __v_65: G = G::from_bool((__v_64 == G::ZERO)); @@ -12293,15 +12379,15 @@ fn aiur_fn_144( return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_66.as_canonical_u64() }); } let __v_67: G = G::from_u64(0); - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_15, __v_19, __v_18, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_15, __v_19, __v_18, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_10, __v_27, __v_68, __v_0, __v_28, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_10, __v_27, __v_68, __v_0, __v_28, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; let __v_70: G = G::from_u64(1); if (__v_69 != __v_70) { return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_70.as_canonical_u64() }); } - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; let __v_72: G = (__v_71 - __v_18); let __v_73: G = G::from_bool((__v_72 == G::ZERO)); @@ -12310,15 +12396,15 @@ fn aiur_fn_144( return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64() }); } let __v_75: G = G::from_u64(0); - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_15, __v_19, __v_18, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_15, __v_19, __v_18, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_11, __v_32, __v_76, __v_0, __v_33, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_11, __v_32, __v_76, __v_0, __v_33, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); if (__v_77 != __v_78) { return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_78.as_canonical_u64() }); } - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; let __v_80: G = (__v_79 - __v_18); let __v_81: G = G::from_bool((__v_80 == G::ZERO)); @@ -12327,9 +12413,9 @@ fn aiur_fn_144( return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_82.as_canonical_u64() }); } let __v_83: G = G::from_u64(0); - let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_15, __v_19, __v_18, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_15, __v_19, __v_18, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_138] = unsafe { *(result.output.as_ptr() as *const [G; OUT_138]) }; __ret } else { aiur_fn_138(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; - let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_12, __v_37, __v_84, __v_0, __v_38, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_12, __v_37, __v_84, __v_0, __v_38, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; let __v_85: G = __r_arr[0]; let __v_86: G = G::from_u64(1); if (__v_85 != __v_86) { @@ -12342,7 +12428,7 @@ fn aiur_fn_144( return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_89.as_canonical_u64() }); } let __v_90: G = G::from_u64(0); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_23, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_23, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_91: G = __r_arr[0]; let __v_92: G = __r_arr[1]; let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_91, __v_92, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; @@ -12352,8 +12438,8 @@ fn aiur_fn_144( return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_94.as_canonical_u64() }); } let __v_95: G = G::from_u64(1); - let __ret: [G; OUT_144] = [__v_95]; - record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_145] = [__v_95]; + record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -12373,15 +12459,15 @@ fn aiur_fn_144( }) } -const INPUT_SIZE_145: usize = 25; -const IN_145: usize = 25; -const OUT_145: usize = 1; -fn aiur_fn_145( - inp: [G; IN_145], +const INPUT_SIZE_146: usize = 25; +const IN_146: usize = 25; +const OUT_146: usize = 1; +fn aiur_fn_146( + inp: [G; IN_146], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_145], ExecError> { +) -> Result<[G; OUT_146], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12416,21 +12502,21 @@ fn aiur_fn_145( match __v_25.as_canonical_u64() { 1u64 => { let __v_29: G = G::from_u64(1); - let __ret: [G; OUT_145] = [__v_29]; - record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_146] = [__v_29]; + record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_0, __v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = __r_arr[1]; let __v_31: G = __r_arr[2]; - let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_144] = unsafe { *(result.output.as_ptr() as *const [G; OUT_144]) }; __ret } else { aiur_fn_144(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_29, __v_26, __v_27, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_30, __v_31, __v_28, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !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_33: G = __r_arr[0]; - let __ret: [G; OUT_145] = [__v_33]; - record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_146] = [__v_33]; + record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -12440,15 +12526,15 @@ fn aiur_fn_145( }) } -const INPUT_SIZE_146: usize = 31; -const IN_146: usize = 31; -const OUT_146: usize = 1; -fn aiur_fn_146( - inp: [G; IN_146], +const INPUT_SIZE_147: usize = 31; +const IN_147: usize = 31; +const OUT_147: usize = 1; +fn aiur_fn_147( + inp: [G; IN_147], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_146], ExecError> { +) -> Result<[G; OUT_147], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12483,25 +12569,25 @@ fn aiur_fn_146( let __v_30: G = inp[30]; match __v_6.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_31: G = __r_arr[0]; let __v_32: G = G::from_u64(1); let __v_33: G = G::from_u64(1); let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4, __v_5, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_4, __v_5, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_2, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_0, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = G::from_u64(1); let __v_41: G = G::from_u64(1); let __v_42: G = { let __values: [G; 3] = [__v_40, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_39, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_43: G = __r_arr[0]; let __v_44: G = __r_arr[1]; let __v_45: G = __r_arr[2]; @@ -12524,23 +12610,23 @@ fn aiur_fn_146( let __v_61: G = __r_arr[0]; let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; - let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_59, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_59, __v_6, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[126].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_126] = unsafe { *(result.output.as_ptr() as *const [G; OUT_126]) }; __ret } else { aiur_fn_126(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; let __v_64: G = __r_arr[1]; let __v_65: G = G::from_u64(1); let __v_66: G = G::from_u64(1); let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_9, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_9, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_64, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_64, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_69, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_69, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; - let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_70, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_70, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; let __v_71: G = __r_arr[0]; let __v_72: G = __r_arr[1]; let __v_73: G = (__v_31 + __v_27); - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = (__v_74 - __v_31); let __v_76: G = G::from_bool((__v_75 == G::ZERO)); @@ -12548,7 +12634,7 @@ fn aiur_fn_146( if (__v_76 != __v_77) { return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64() }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !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_78: G = __r_arr[0]; let __v_79: G = (__v_78 - __v_28); let __v_80: G = G::from_bool((__v_79 == G::ZERO)); @@ -12556,52 +12642,52 @@ fn aiur_fn_146( if (__v_80 != __v_81) { return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_81.as_canonical_u64() }); } - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !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_82: G = __r_arr[0]; let __v_83: G = G::from_u64(1); if (__v_82 != __v_83) { return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_83.as_canonical_u64() }); } - let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_71, __v_72, __v_8, __v_61, __v_62, __v_1, __v_2, __v_3, __v_4, __v_5, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_73, __v_63, __v_6, __v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_145] = unsafe { *(result.output.as_ptr() as *const [G; OUT_145]) }; __ret } else { aiur_fn_145(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_71, __v_72, __v_8, __v_61, __v_62, __v_1, __v_2, __v_3, __v_4, __v_5, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_73, __v_63, __v_6, __v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; let __v_84: G = __r_arr[0]; - let __ret: [G; OUT_146] = [__v_84]; - record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_147] = [__v_84]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_147: usize = 2; -const IN_147: usize = 2; -const OUT_147: usize = 1; -fn aiur_fn_147( - inp: [G; IN_147], +const INPUT_SIZE_148: usize = 2; +const IN_148: usize = 2; +const OUT_148: usize = 1; +fn aiur_fn_148( + inp: [G; IN_148], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_147], ExecError> { +) -> Result<[G; OUT_148], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = G::from_bool((__v_0 == G::ZERO)); let __v_3: G = G::from_bool((__v_1 == G::ZERO)); let __v_4: G = (__v_2 * __v_3); - let __ret: [G; OUT_147] = [__v_4]; - record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_148] = [__v_4]; + record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_148: usize = 1; -const IN_148: usize = 1; -const OUT_148: usize = 1; -fn aiur_fn_148( - inp: [G; IN_148], +const INPUT_SIZE_149: usize = 1; +const IN_149: usize = 1; +const OUT_149: usize = 1; +fn aiur_fn_149( + inp: [G; IN_149], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_148], ExecError> { +) -> Result<[G; OUT_149], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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 }; @@ -12612,8 +12698,8 @@ fn aiur_fn_148( match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_148] = [__v_5]; - record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_149] = [__v_5]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -12624,17 +12710,17 @@ fn aiur_fn_148( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 1u64 => { - let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_148] = [__v_9]; - record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_149] = [__v_9]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_148] = [__v_9]; - record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_149] = [__v_9]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -12646,15 +12732,15 @@ fn aiur_fn_148( }) } -const INPUT_SIZE_149: usize = 9; -const IN_149: usize = 9; -const OUT_149: usize = 1; -fn aiur_fn_149( - inp: [G; IN_149], +const INPUT_SIZE_150: usize = 9; +const IN_150: usize = 9; +const OUT_150: usize = 1; +fn aiur_fn_150( + inp: [G; IN_150], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_149], ExecError> { +) -> Result<[G; OUT_150], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12681,21 +12767,21 @@ fn aiur_fn_149( let __v_22: G = { let __values: [G; 3] = [__v_11, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_23: G = { let __values: [G; 3] = [__v_10, __v_1, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_24: G = { let __values: [G; 3] = [__v_9, __v_0, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_149] = [__v_24]; - record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_150] = [__v_24]; + record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_150: usize = 33; -const IN_150: usize = 33; -const OUT_150: usize = 1; -fn aiur_fn_150( - inp: [G; IN_150], +const INPUT_SIZE_151: usize = 33; +const IN_151: usize = 33; +const OUT_151: usize = 1; +fn aiur_fn_151( + inp: [G; IN_151], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_150], ExecError> { +) -> Result<[G; OUT_151], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12730,29 +12816,29 @@ fn aiur_fn_150( let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__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[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_33: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_34: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __ret: [G; OUT_150] = [__v_36]; - record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_151] = [__v_36]; + record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_151: usize = 2; -const IN_151: usize = 2; -const OUT_151: usize = 1; -fn aiur_fn_151( - inp: [G; IN_151], +const INPUT_SIZE_152: usize = 2; +const IN_152: usize = 2; +const OUT_152: usize = 1; +fn aiur_fn_152( + inp: [G; IN_152], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_151], ExecError> { +) -> Result<[G; OUT_152], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12793,17 +12879,17 @@ fn aiur_fn_151( let __v_35: G = __loaded[33]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_151] = [__v_1]; - record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_152] = [__v_1]; + record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_35, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_35, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; - let __ret: [G; OUT_151] = [__v_37]; - record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_152] = [__v_37]; + record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -12813,15 +12899,15 @@ fn aiur_fn_151( }) } -const INPUT_SIZE_152: usize = 2; -const IN_152: usize = 2; -const OUT_152: usize = 1; -fn aiur_fn_152( - inp: [G; IN_152], +const INPUT_SIZE_153: usize = 2; +const IN_153: usize = 2; +const OUT_153: usize = 1; +fn aiur_fn_153( + inp: [G; IN_153], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_152], ExecError> { +) -> Result<[G; OUT_153], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12831,8 +12917,8 @@ fn aiur_fn_152( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_152] = [__v_1]; - record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_153] = [__v_1]; + record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -12843,12 +12929,12 @@ fn aiur_fn_152( let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); let __v_11: G = G::from_u64(0); - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_3, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_152] = [__v_13]; - record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_153] = [__v_13]; + record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -12858,15 +12944,15 @@ fn aiur_fn_152( }) } -const INPUT_SIZE_153: usize = 2; -const IN_153: usize = 2; -const OUT_153: usize = 3; -fn aiur_fn_153( - inp: [G; IN_153], +const INPUT_SIZE_154: usize = 2; +const IN_154: usize = 2; +const OUT_154: usize = 3; +fn aiur_fn_154( + inp: [G; IN_154], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_153], ExecError> { +) -> Result<[G; OUT_154], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -12876,8 +12962,8 @@ fn aiur_fn_153( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_153] = [__v_3, __v_0, __v_4]; - record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_154] = [__v_3, __v_0, __v_4]; + record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -12917,12 +13003,12 @@ fn aiur_fn_153( 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_94] = { let __args: [G; IN_94] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; let __v_41: G = G::from_u64(1); let __v_42: G = G::from_u64(1); let __v_43: G = { let __values: [G; 3] = [__v_41, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_40, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_40, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; let __v_44: G = __r_arr[0]; let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_44.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; let __v_45: G = __loaded[0]; @@ -12930,8 +13016,8 @@ fn aiur_fn_153( let __v_47: G = __loaded[2]; match __v_45.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_153] = [__v_46, __v_40, __v_47]; - record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_154] = [__v_46, __v_40, __v_47]; + record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -12946,69 +13032,69 @@ fn aiur_fn_153( }) } -const INPUT_SIZE_154: usize = 2; -const IN_154: usize = 2; -const OUT_154: usize = 10; -fn aiur_fn_154( - inp: [G; IN_154], +const INPUT_SIZE_155: usize = 2; +const IN_155: usize = 2; +const OUT_155: usize = 10; +fn aiur_fn_155( + inp: [G; IN_155], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_154], ExecError> { +) -> Result<[G; OUT_155], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; let __v_10: G = __r_arr[2]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; let __v_15: G = __r_arr[1]; let __v_16: G = __r_arr[2]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; let __v_18: G = __r_arr[1]; let __v_19: G = __r_arr[2]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_20: G = __r_arr[0]; let __v_21: G = __r_arr[1]; let __v_22: G = __r_arr[2]; - let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; let __v_25: G = __r_arr[2]; - let __ret: [G; OUT_154] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_24, __v_25]; - record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_155] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_24, __v_25]; + record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_155: usize = 2; -const IN_155: usize = 2; -const OUT_155: usize = 10; -fn aiur_fn_155( - inp: [G; IN_155], +const INPUT_SIZE_156: usize = 2; +const IN_156: usize = 2; +const OUT_156: usize = 10; +fn aiur_fn_156( + inp: [G; IN_156], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_155], ExecError> { +) -> Result<[G; OUT_156], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13023,12 +13109,12 @@ fn aiur_fn_155( let __v_12: G = __r_arr[0]; match __v_12.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_155] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_156] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = __r_arr[2]; @@ -13039,27 +13125,27 @@ fn aiur_fn_155( let __v_20: G = __r_arr[7]; let __v_21: G = __r_arr[8]; let __v_22: G = __r_arr[9]; - let __ret: [G; OUT_155] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; - record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_156] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_156: usize = 2; -const IN_156: usize = 2; -const OUT_156: usize = 18; -fn aiur_fn_156( - inp: [G; IN_156], +const INPUT_SIZE_157: usize = 2; +const IN_157: usize = 2; +const OUT_157: usize = 18; +fn aiur_fn_157( + inp: [G; IN_157], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_156], ExecError> { +) -> Result<[G; OUT_157], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13070,7 +13156,7 @@ fn aiur_fn_156( let __v_9: G = __r_arr[7]; let __v_10: G = __r_arr[8]; let __v_11: G = __r_arr[9]; - let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = __r_arr[1]; let __v_14: G = __r_arr[2]; @@ -13081,21 +13167,21 @@ fn aiur_fn_156( let __v_19: G = __r_arr[7]; let __v_20: G = __r_arr[8]; let __v_21: G = __r_arr[9]; - let __ret: [G; OUT_156] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; - record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_157] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_157: usize = 8; -const IN_157: usize = 8; -const OUT_157: usize = 1; -fn aiur_fn_157( - inp: [G; IN_157], +const INPUT_SIZE_158: usize = 8; +const IN_158: usize = 8; +const OUT_158: usize = 1; +fn aiur_fn_158( + inp: [G; IN_158], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_157], ExecError> { +) -> Result<[G; OUT_158], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13180,37 +13266,37 @@ fn aiur_fn_157( let __v_72: G = G::from_u64(1); let __v_73: G = G::from_u64(1); let __v_74: G = { let __values: [G; 3] = [__v_72, __v_73, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_75: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_76: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_77: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_78: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_79: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_80: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_81: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_82: G = __r_arr[0]; - let __ret: [G; OUT_157] = [__v_82]; - record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_158] = [__v_82]; + record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_158: usize = 2; -const IN_158: usize = 2; -const OUT_158: usize = 1; -fn aiur_fn_158( - inp: [G; IN_158], +const INPUT_SIZE_159: usize = 2; +const IN_159: usize = 2; +const OUT_159: usize = 1; +fn aiur_fn_159( + inp: [G; IN_159], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_158], ExecError> { +) -> Result<[G; OUT_159], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13219,8 +13305,8 @@ fn aiur_fn_158( 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_158] = [__v_4]; - record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_159] = [__v_4]; + record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -13233,11 +13319,11 @@ fn aiur_fn_158( 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_158] = { let __args: [G; IN_158] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_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_158] = [__v_9]; - record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_159] = [__v_9]; + record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -13249,20 +13335,20 @@ fn aiur_fn_158( }) } -const INPUT_SIZE_159: usize = 3; -const IN_159: usize = 3; -const OUT_159: usize = 3; -fn aiur_fn_159( - inp: [G; IN_159], +const INPUT_SIZE_160: usize = 3; +const IN_160: usize = 3; +const OUT_160: usize = 3; +fn aiur_fn_160( + inp: [G; IN_160], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_159], ExecError> { +) -> Result<[G; OUT_160], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_155] = unsafe { *(result.output.as_ptr() as *const [G; OUT_155]) }; __ret } else { aiur_fn_155(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = __r_arr[2]; @@ -13273,25 +13359,25 @@ fn aiur_fn_159( let __v_10: G = __r_arr[7]; let __v_11: G = __r_arr[8]; let __v_12: G = __r_arr[9]; - let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__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[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_13, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __ret: [G; OUT_159] = [__v_14, __v_11, __v_12]; - record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_160] = [__v_14, __v_11, __v_12]; + record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_160: usize = 9; -const IN_160: usize = 9; -const OUT_160: usize = 1; -fn aiur_fn_160( - inp: [G; IN_160], +const INPUT_SIZE_161: usize = 9; +const IN_161: usize = 9; +const OUT_161: usize = 1; +fn aiur_fn_161( + inp: [G; IN_161], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_160], ExecError> { +) -> Result<[G; OUT_161], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13305,50 +13391,50 @@ fn aiur_fn_160( 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_149] = { let __args: [G; IN_149] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_160] = [__v_13]; - record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_161] = [__v_13]; + record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_161: usize = 2; -const IN_161: usize = 2; -const OUT_161: usize = 1; -fn aiur_fn_161( - inp: [G; IN_161], +const INPUT_SIZE_162: usize = 2; +const IN_162: usize = 2; +const OUT_162: usize = 1; +fn aiur_fn_162( + inp: [G; IN_162], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_161], ExecError> { +) -> Result<[G; OUT_162], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; 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_151] = { let __args: [G; IN_151] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; - let __ret: [G; OUT_161] = [__v_6]; - record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_162] = [__v_6]; + record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_162: usize = 2; -const IN_162: usize = 2; -const OUT_162: usize = 1; -fn aiur_fn_162( - inp: [G; IN_162], +const INPUT_SIZE_163: usize = 2; +const IN_163: usize = 2; +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_162], ExecError> { +) -> Result<[G; OUT_163], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13365,17 +13451,17 @@ fn aiur_fn_162( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_162] = [__v_1]; - record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_163] = [__v_1]; + record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __ret: [G; OUT_162] = [__v_13]; - record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_163] = [__v_13]; + record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -13385,15 +13471,15 @@ fn aiur_fn_162( }) } -const INPUT_SIZE_163: usize = 2; -const IN_163: usize = 2; -const OUT_163: usize = 1; -fn aiur_fn_163( - inp: [G; IN_163], +const INPUT_SIZE_164: usize = 2; +const IN_164: usize = 2; +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_163], ExecError> { +) -> Result<[G; OUT_164], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13403,12 +13489,12 @@ fn aiur_fn_163( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_163] = [__v_1]; - record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_164] = [__v_1]; + record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = __r_arr[1]; let __v_7: G = __r_arr[2]; @@ -13417,14 +13503,14 @@ fn aiur_fn_163( let __v_10: G = __r_arr[5]; let __v_11: G = __r_arr[6]; let __v_12: G = __r_arr[7]; - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __ret: [G; OUT_163] = [__v_15]; - record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_164] = [__v_15]; + record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -13434,19 +13520,19 @@ fn aiur_fn_163( }) } -const INPUT_SIZE_164: usize = 2; -const IN_164: usize = 2; -const OUT_164: usize = 1; -fn aiur_fn_164( - inp: [G; IN_164], +const INPUT_SIZE_165: usize = 2; +const IN_165: usize = 2; +const OUT_165: usize = 1; +fn aiur_fn_165( + inp: [G; IN_165], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_164], ExecError> { +) -> Result<[G; OUT_165], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = __r_arr[2]; @@ -13455,25 +13541,25 @@ fn aiur_fn_164( let __v_7: G = __r_arr[5]; let __v_8: G = __r_arr[6]; let __v_9: G = __r_arr[7]; - let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !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_10: G = __r_arr[0]; - let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__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[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__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[150].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_150] = unsafe { *(result.output.as_ptr() as *const [G; OUT_150]) }; __ret } else { aiur_fn_150(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; - let __ret: [G; OUT_164] = [__v_11]; - record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_165] = [__v_11]; + record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_165: usize = 1; -const IN_165: usize = 1; -const OUT_165: usize = 1; -fn aiur_fn_165( - inp: [G; IN_165], +const INPUT_SIZE_166: usize = 1; +const IN_166: usize = 1; +const OUT_166: usize = 1; +fn aiur_fn_166( + inp: [G; IN_166], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_165], ExecError> { +) -> Result<[G; OUT_166], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = G::from_u64(0); @@ -13518,21 +13604,21 @@ fn aiur_fn_165( let __v_40: G = { let __values: [G; 3] = [__v_5, __v_6, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_41: G = { let __values: [G; 3] = [__v_3, __v_4, __v_40]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_42: G = { let __values: [G; 3] = [__v_1, __v_2, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_165] = [__v_42]; - record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_166] = [__v_42]; + record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_166: usize = 2; -const IN_166: usize = 2; -const OUT_166: usize = 1; -fn aiur_fn_166( - inp: [G; IN_166], +const INPUT_SIZE_167: usize = 2; +const IN_167: usize = 2; +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_166], ExecError> { +) -> Result<[G; OUT_167], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13541,13 +13627,13 @@ fn aiur_fn_166( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 34] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_166] = [__v_4]; - record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_167] = [__v_4]; + record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __ret: [G; OUT_166] = [__v_1]; - record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_167] = [__v_1]; + record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -13557,15 +13643,15 @@ fn aiur_fn_166( }) } -const INPUT_SIZE_167: usize = 9; -const IN_167: usize = 9; -const OUT_167: usize = 9; -fn aiur_fn_167( - inp: [G; IN_167], +const INPUT_SIZE_168: usize = 9; +const IN_168: usize = 9; +const OUT_168: usize = 9; +fn aiur_fn_168( + inp: [G; IN_168], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_167], ExecError> { +) -> Result<[G; OUT_168], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -13579,24 +13665,24 @@ fn aiur_fn_167( let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_6, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_6, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_3, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_14: G = __r_arr[0]; - let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; - let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_153] = unsafe { *(result.output.as_ptr() as *const [G; OUT_153]) }; __ret } else { aiur_fn_153(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; - let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_163] = unsafe { *(result.output.as_ptr() as *const [G; OUT_163]) }; __ret } else { aiur_fn_163(__args, record, io_buffer, __cu)? } }; let __v_17: G = __r_arr[0]; - let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_165] = unsafe { *(result.output.as_ptr() as *const [G; OUT_165]) }; __ret } else { aiur_fn_165(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = G::from_u64(1); let __v_20: G = G::from_u64(1); let __v_21: G = { let __values: [G; 3] = [__v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; @@ -13615,14 +13701,14 @@ fn aiur_fn_167( let __v_37: G = __r_arr[15]; let __v_38: G = __r_arr[16]; let __v_39: G = __r_arr[17]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_38, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_38, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_40, __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[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_40, __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[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; let __v_42: G = G::from_u64(1); let __v_43: G = G::from_u64(1); let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_41, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_41, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_45: G = __r_arr[0]; let __v_46: G = __r_arr[1]; let __v_47: G = __r_arr[2]; @@ -13641,23 +13727,23 @@ fn aiur_fn_167( let __v_60: G = __r_arr[15]; let __v_61: G = __r_arr[16]; let __v_62: G = __r_arr[17]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_61, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_61, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_63, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_160] = unsafe { *(result.output.as_ptr() as *const [G; OUT_160]) }; __ret } else { aiur_fn_160(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_63, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_64, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_64, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_65: G = __r_arr[0]; let __v_66: G = G::from_u64(1); let __v_67: G = G::from_u64(1); let __v_68: G = { let __values: [G; 3] = [__v_66, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_8, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_8, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_120] = unsafe { *(result.output.as_ptr() as *const [G; OUT_120]) }; __ret } else { aiur_fn_120(__args, record, io_buffer, __cu)? } }; let __v_69: G = __r_arr[0]; - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_65, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_65, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = G::from_u64(1); let __v_72: G = G::from_u64(1); let __v_73: G = { let __values: [G; 3] = [__v_71, __v_72, __v_72]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_70, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_70, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_74: G = __r_arr[0]; let __v_75: G = __r_arr[1]; let __v_76: G = __r_arr[2]; @@ -13676,12 +13762,12 @@ fn aiur_fn_167( let __v_89: G = __r_arr[15]; let __v_90: G = __r_arr[16]; let __v_91: G = __r_arr[17]; - let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_90, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_90, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_162] = unsafe { *(result.output.as_ptr() as *const [G; OUT_162]) }; __ret } else { aiur_fn_162(__args, record, io_buffer, __cu)? } }; let __v_92: G = __r_arr[0]; let __v_93: G = G::from_u64(1); let __v_94: G = G::from_u64(1); let __v_95: G = { let __values: [G; 3] = [__v_93, __v_94, __v_94]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_92, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_92, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_157] = unsafe { *(result.output.as_ptr() as *const [G; OUT_157]) }; __ret } else { aiur_fn_157(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -13716,29 +13802,29 @@ fn aiur_fn_167( let __v_120: G = __r_arr[0]; let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_121: G = __r_arr[0]; - let __ret: [G; OUT_167] = [__v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_112]; - record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_168] = [__v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_112]; + record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_168: usize = 3; -const IN_168: usize = 3; -const OUT_168: usize = 2; -fn aiur_fn_168( - inp: [G; IN_168], +const INPUT_SIZE_169: usize = 3; +const IN_169: usize = 3; +const OUT_169: usize = 2; +fn aiur_fn_169( + inp: [G; IN_169], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_168], ExecError> { +) -> Result<[G; OUT_169], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; match __v_2.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_168] = [__v_0, __v_1]; - record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_169] = [__v_0, __v_1]; + record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -13747,245 +13833,245 @@ fn aiur_fn_168( let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_2 - __v_5); - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_3, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_3, __v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_168] = [__v_7, __v_8]; - record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_169] = [__v_7, __v_8]; + record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_169: usize = 1; -const IN_169: usize = 1; -const OUT_169: usize = 1; -fn aiur_fn_169( - inp: [G; IN_169], +const INPUT_SIZE_170: usize = 1; +const IN_170: usize = 1; +const OUT_170: usize = 1; +fn aiur_fn_170( + inp: [G; IN_170], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_169], ExecError> { +) -> Result<[G; OUT_170], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(18446744069414584320); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(281474976710656); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(18446744069397807105); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(17293822564807737345); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(70368744161280); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(549755813888); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(17870292113338400769); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(13797081185216407910); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(1803076106186727246); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(11353340290879379826); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(455906449640507599); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(17492915097719143606); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(1532612707718625687); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16207902636198568418); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(17776499369601055404); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(6115771955107415310); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(12380578893860276750); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 18u64 => { let __v_1: G = G::from_u64(9306717745644682924); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 19u64 => { let __v_1: G = G::from_u64(18146160046829613826); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 20u64 => { let __v_1: G = G::from_u64(3511170319078647661); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 21u64 => { let __v_1: G = G::from_u64(17654865857378133588); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 22u64 => { let __v_1: G = G::from_u64(5416168637041100469); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 23u64 => { let __v_1: G = G::from_u64(16905767614792059275); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 24u64 => { let __v_1: G = G::from_u64(9713644485405565297); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 25u64 => { let __v_1: G = G::from_u64(5456943929260765144); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 26u64 => { let __v_1: G = G::from_u64(17096174751763063430); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 27u64 => { let __v_1: G = G::from_u64(1213594585890690845); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 28u64 => { let __v_1: G = G::from_u64(6414415596519834757); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 29u64 => { let __v_1: G = G::from_u64(16116352524544190054); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 30u64 => { let __v_1: G = G::from_u64(9123114210336311365); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 31u64 => { let __v_1: G = G::from_u64(4614640910117430873); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(1753635133440165772); - let __ret: [G; OUT_169] = [__v_1]; - record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_170] = [__v_1]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_170: usize = 3; -const IN_170: usize = 3; -const OUT_170: usize = 2; -fn aiur_fn_170( - inp: [G; IN_170], +const INPUT_SIZE_171: usize = 3; +const IN_171: usize = 3; +const OUT_171: usize = 2; +fn aiur_fn_171( + inp: [G; IN_171], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_170], ExecError> { +) -> Result<[G; OUT_171], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; let __v_5: G = G::from_u64(1); @@ -13993,62 +14079,62 @@ fn aiur_fn_170( let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_7: G = __r_arr[0]; let __v_8: G = __r_arr[1]; - let __ret: [G; OUT_170] = [__v_7, __v_8]; - record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_171] = [__v_7, __v_8]; + record.function_queries[171].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_172: usize = 1; +const IN_172: usize = 1; +const OUT_172: usize = 1; +fn aiur_fn_172( + inp: [G; IN_172], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_171], ExecError> { +) -> Result<[G; OUT_172], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_171] = [__v_1]; - record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_172] = [__v_1]; + record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(2); let __v_2: G = G::from_u64(1); let __v_3: G = (__v_0 - __v_2); - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = (__v_1 * __v_4); - let __ret: [G; OUT_171] = [__v_5]; - record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_172] = [__v_5]; + record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_172: usize = 3; -const IN_172: usize = 3; -const OUT_172: usize = 8; -fn aiur_fn_172( - inp: [G; IN_172], +const INPUT_SIZE_173: usize = 3; +const IN_173: usize = 3; +const OUT_173: usize = 8; +fn aiur_fn_173( + inp: [G; IN_173], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_172], ExecError> { +) -> Result<[G; OUT_173], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; let __v_2: G = inp[2]; - let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; @@ -14074,21 +14160,21 @@ fn aiur_fn_172( let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_172] = [__v_11, __v_12, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22]; - record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_173] = [__v_11, __v_12, __v_16, __v_17, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_173: usize = 23; -const IN_173: usize = 23; -const OUT_173: usize = 1; -fn aiur_fn_173( - inp: [G; IN_173], +const INPUT_SIZE_174: usize = 23; +const IN_174: usize = 23; +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_173], ExecError> { +) -> Result<[G; OUT_174], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14115,52 +14201,52 @@ fn aiur_fn_173( let __v_22: G = inp[22]; match __v_0.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !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_23: G = __r_arr[0]; let __v_24: G = G::from_bool((__v_23 == G::ZERO)); let __v_25: G = G::from_u64(0); if (__v_24 != __v_25) { return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_25.as_canonical_u64() }); } - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; if (__v_26 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); } - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_27: G = __r_arr[0]; if (__v_27 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); } - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; if (__v_28 != __v_23) { return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); } - let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_148] = unsafe { *(result.output.as_ptr() as *const [G; OUT_148]) }; __ret } else { aiur_fn_148(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; let __v_30: G = G::from_u64(1); if (__v_29 != __v_30) { return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_30.as_canonical_u64() }); } let __v_31: G = G::from_u64(1); - let __ret: [G; OUT_173] = [__v_31]; - record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_174] = [__v_31]; + record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_174: usize = 6; -const IN_174: usize = 6; -const OUT_174: usize = 2; -fn aiur_fn_174( - inp: [G; IN_174], +const INPUT_SIZE_175: usize = 6; +const IN_175: usize = 6; +const OUT_175: usize = 2; +fn aiur_fn_175( + inp: [G; IN_175], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_174], ExecError> { +) -> Result<[G; OUT_175], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14174,21 +14260,21 @@ fn aiur_fn_174( let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_174] = [__v_8, __v_9]; - record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_175] = [__v_8, __v_9]; + record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_175: usize = 4; -const IN_175: usize = 4; -const OUT_175: usize = 2; -fn aiur_fn_175( - inp: [G; IN_175], +const INPUT_SIZE_176: usize = 4; +const IN_176: usize = 4; +const OUT_176: usize = 2; +fn aiur_fn_176( + inp: [G; IN_176], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_175], ExecError> { +) -> Result<[G; OUT_176], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14202,21 +14288,21 @@ fn aiur_fn_175( let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0, __v_1, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = __r_arr[1]; - let __ret: [G; OUT_175] = [__v_8, __v_9]; - record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_176] = [__v_8, __v_9]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_176: usize = 1; -const IN_176: usize = 1; -const OUT_176: usize = 1; -fn aiur_fn_176( - inp: [G; IN_176], +const INPUT_SIZE_177: usize = 1; +const IN_177: usize = 1; +const OUT_177: usize = 1; +fn aiur_fn_177( + inp: [G; IN_177], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_176], ExecError> { +) -> Result<[G; OUT_177], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; 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 }; @@ -14229,8 +14315,8 @@ fn aiur_fn_176( let __v_5: G = G::from_u64(1); let __v_6: G = G::from_u64(1); let __v_7: G = { let __values: [G; 4] = [__v_5, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_176] = [__v_7]; - record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_177] = [__v_7]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -14242,14 +14328,14 @@ fn aiur_fn_176( match __v_5.as_canonical_u64() { 0u64 => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_2, __v_3, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_12: G = __r_arr[0]; let __v_13: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_176] = [__v_13]; - record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_177] = [__v_13]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -14264,15 +14350,15 @@ fn aiur_fn_176( }) } -const INPUT_SIZE_177: usize = 15; -const IN_177: usize = 15; -const OUT_177: usize = 2; -fn aiur_fn_177( - inp: [G; IN_177], +const INPUT_SIZE_178: usize = 15; +const IN_178: usize = 15; +const OUT_178: usize = 2; +fn aiur_fn_178( + inp: [G; IN_178], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_177], ExecError> { +) -> Result<[G; OUT_178], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14289,7 +14375,7 @@ fn aiur_fn_177( let __v_12: G = inp[12]; let __v_13: G = inp[13]; let __v_14: G = inp[14]; - let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __v_17: G = __r_arr[2]; @@ -14297,8 +14383,8 @@ fn aiur_fn_177( match __v_15.as_canonical_u64() { 0u64 => { let __v_19: G = G::from_u64(0); - let __ret: [G; OUT_177] = [__v_16, __v_19]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_16, __v_19]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -14306,129 +14392,129 @@ fn aiur_fn_177( let __v_20: G = (__v_16 + __v_19); match __v_20.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_177] = [__v_21, __v_22]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_21, __v_22]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_177] = [__v_21, __v_22]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_21, __v_22]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_2, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_177] = [__v_21, __v_22]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_21, __v_22]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_177] = [__v_21, __v_22]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_21, __v_22]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_177] = [__v_21, __v_22]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_21, __v_22]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_177] = [__v_21, __v_22]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_21, __v_22]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, 2u64 => { - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_8, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_177] = [__v_19, __v_20]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_19, __v_20]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { - let __ret: [G; OUT_177] = [__v_9, __v_10]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_9, __v_10]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { - let __ret: [G; OUT_177] = [__v_11, __v_12]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_11, __v_12]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { - let __ret: [G; OUT_177] = [__v_13, __v_14]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_13, __v_14]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __ret: [G; OUT_177] = [__v_23, __v_24]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_23, __v_24]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __ret: [G; OUT_177] = [__v_23, __v_24]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_23, __v_24]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __v_23: G = __r_arr[0]; let __v_24: G = __r_arr[1]; - let __ret: [G; OUT_177] = [__v_23, __v_24]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_23, __v_24]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 9u64 => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_0, __v_16, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; let __r_arr: [G; OUT_19] = { let __args: [G; IN_19] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[19].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_19] = unsafe { *(result.output.as_ptr() as *const [G; OUT_19]) }; __ret } else { aiur_fn_19(__args, record, io_buffer, __cu)? } }; let __v_21: G = __r_arr[0]; let __v_22: G = __r_arr[1]; - let __ret: [G; OUT_177] = [__v_21, __v_22]; - record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_178] = [__v_21, __v_22]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -14438,15 +14524,15 @@ fn aiur_fn_177( }) } -const INPUT_SIZE_178: usize = 19; -const IN_178: usize = 19; -const OUT_178: usize = 2; -fn aiur_fn_178( - inp: [G; IN_178], +const INPUT_SIZE_179: usize = 19; +const IN_179: usize = 19; +const OUT_179: usize = 2; +fn aiur_fn_179( + inp: [G; IN_179], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_178], ExecError> { +) -> Result<[G; OUT_179], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14473,22 +14559,22 @@ fn aiur_fn_178( let __v_21: G = __loaded[2]; match __v_19.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_178] = [__v_0, __v_1]; - record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_179] = [__v_0, __v_1]; + record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_0, __v_1, __v_2, __v_3, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; let __v_24: G = __r_arr[0]; let __v_25: G = __r_arr[1]; - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_179] = { let __args: [G; IN_179] = [__v_24, __v_25, __v_2, __v_3, __v_21, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; - let __ret: [G; OUT_178] = [__v_26, __v_27]; - record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_179] = [__v_26, __v_27]; + record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -14498,15 +14584,15 @@ fn aiur_fn_178( }) } -const INPUT_SIZE_179: usize = 8; -const IN_179: usize = 8; -const OUT_179: usize = 4; -fn aiur_fn_179( - inp: [G; IN_179], +const INPUT_SIZE_180: usize = 8; +const IN_180: usize = 8; +const OUT_180: usize = 4; +fn aiur_fn_180( + inp: [G; IN_180], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_179], ExecError> { +) -> Result<[G; OUT_180], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14539,21 +14625,21 @@ fn aiur_fn_179( let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; - let __ret: [G; OUT_179] = [__v_16, __v_17, __v_22, __v_23]; - record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_180] = [__v_16, __v_17, __v_22, __v_23]; + record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_180: usize = 19; -const IN_180: usize = 19; -const OUT_180: usize = 4; -fn aiur_fn_180( - inp: [G; IN_180], +const INPUT_SIZE_181: usize = 19; +const IN_181: usize = 19; +const OUT_181: usize = 4; +fn aiur_fn_181( + inp: [G; IN_181], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_180], ExecError> { +) -> Result<[G; OUT_181], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14584,29 +14670,29 @@ fn aiur_fn_180( let __v_23: G = G::from_u64(0); let __v_24: G = G::from_u64(0); let __v_25: G = G::from_u64(0); - let __ret: [G; OUT_180] = [__v_22, __v_23, __v_24, __v_25]; - record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_181] = [__v_22, __v_23, __v_24, __v_25]; + record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_21, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; let __v_22: G = __r_arr[0]; let __v_23: G = __r_arr[1]; let __v_24: G = __r_arr[2]; let __v_25: G = __r_arr[3]; - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_22, __v_23, __v_24, __v_25, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_26: G = __r_arr[0]; let __v_27: G = __r_arr[1]; let __v_28: G = __r_arr[2]; let __v_29: G = __r_arr[3]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_5, __v_20, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_30: G = __r_arr[0]; let __v_31: G = __r_arr[1]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_26, __v_27, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_32: G = __r_arr[0]; let __v_33: G = __r_arr[1]; - let __ret: [G; OUT_180] = [__v_32, __v_33, __v_28, __v_29]; - record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_181] = [__v_32, __v_33, __v_28, __v_29]; + record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -14616,15 +14702,15 @@ fn aiur_fn_180( }) } -const INPUT_SIZE_181: usize = 33; -const IN_181: usize = 33; -const OUT_181: usize = 2; -fn aiur_fn_181( - inp: [G; IN_181], +const INPUT_SIZE_182: usize = 44; +const IN_182: usize = 44; +const OUT_182: usize = 2; +fn aiur_fn_182( + inp: [G; IN_182], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_181], ExecError> { +) -> Result<[G; OUT_182], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14659,133 +14745,226 @@ fn aiur_fn_181( let __v_30: G = inp[30]; let __v_31: G = inp[31]; let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; - let __v_33: G = __loaded[0]; - let __v_34: G = __loaded[1]; - let __v_35: G = __loaded[2]; - let __v_36: G = __loaded[3]; - match __v_33.as_canonical_u64() { + let __v_44: G = __loaded[0]; + let __v_45: G = __loaded[1]; + let __v_46: G = __loaded[2]; + let __v_47: G = __loaded[3]; + match __v_44.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_181] = [__v_0, __v_1]; - record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_182] = [__v_0, __v_1]; + record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - match __v_34.as_canonical_u64() { + match __v_45.as_canonical_u64() { _ => { - let __v_37: G = (__v_5 + __v_5); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_24, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_38: G = __r_arr[0]; - let __v_39: G = __r_arr[1]; - let __v_40: G = G::from_u64(1); - let __v_41: G = (__v_5 + __v_40); - let __v_42: G = (__v_5 + __v_41); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_24, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_43: G = __r_arr[0]; - let __v_44: G = __r_arr[1]; - let __v_45: G = G::from_u64(1); - let __v_46: G = (__v_45 - __v_6); - let __v_47: G = (__v_5 + __v_46); - let __mc_out___mc_0: [G; 4] = '__mc_0: { match __v_47.as_canonical_u64() { - 0u64 => { - let __v_48: G = G::from_u64(0); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_25, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_49: G = __r_arr[0]; - let __v_50: G = __r_arr[1]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_49, __v_50, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; - let __v_51: G = __r_arr[0]; - let __v_52: G = __r_arr[1]; - let __v_53: G = G::from_u64(1); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_25, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_54: G = __r_arr[0]; - let __v_55: G = __r_arr[1]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_54, __v_55, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; - let __v_56: G = __r_arr[0]; - let __v_57: G = __r_arr[1]; - break '__mc_0 [__v_51, __v_52, __v_56, __v_57]; - }, - _ => { - let __v_48: G = G::from_u64(2); - let __v_49: G = (__v_5 + __v_48); - let __v_50: G = (__v_5 + __v_49); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_24, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_51: G = __r_arr[0]; - let __v_52: G = __r_arr[1]; - let __v_53: G = G::from_u64(3); - let __v_54: G = (__v_5 + __v_53); - let __v_55: G = (__v_5 + __v_54); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_24, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_56: G = __r_arr[0]; - let __v_57: G = __r_arr[1]; - break '__mc_0 [__v_51, __v_52, __v_56, __v_57]; - }, -} - }; - let __v_48: G = __mc_out___mc_0[0]; - let __v_49: G = __mc_out___mc_0[1]; - let __v_50: G = __mc_out___mc_0[2]; - let __v_51: G = __mc_out___mc_0[3]; - let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_35, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_46, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = __r_arr[1]; + let __v_50: G = __r_arr[2]; + let __v_51: G = __r_arr[3]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_48, __v_49, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_52: G = __r_arr[0]; let __v_53: G = __r_arr[1]; - let __v_54: G = __r_arr[2]; - let __v_55: G = __r_arr[3]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_52, __v_53, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_50, __v_51, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __v_55: G = __r_arr[1]; + let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_30, __v_45, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_56: G = __r_arr[0]; let __v_57: G = __r_arr[1]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_54, __v_55, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_14, __v_15, __v_16, __v_17, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; let __v_59: G = __r_arr[1]; - let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_48, __v_49, __v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; - let __v_60: G = __r_arr[0]; - let __v_61: G = __r_arr[1]; - let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_50, __v_51, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[2]; + let __v_61: G = __r_arr[3]; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_56, __v_57, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __v_62: G = __r_arr[0]; let __v_63: G = __r_arr[1]; - let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_58, __v_59, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; let __v_65: G = __r_arr[1]; - let __v_66: G = __r_arr[2]; - let __v_67: G = __r_arr[3]; - let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_19, __v_34, __v_20, __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[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_56, __v_57, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __v_67: G = __r_arr[1]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_60, __v_61, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_68: G = __r_arr[0]; let __v_69: G = __r_arr[1]; - let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_64, __v_65, __v_68, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_10, __v_11, __v_12, __v_13, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; let __v_70: G = __r_arr[0]; let __v_71: G = __r_arr[1]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_0, __v_1, __v_2, __v_3, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; - let __v_72: G = __r_arr[0]; - let __v_73: G = __r_arr[1]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_72, __v_73, __v_2, __v_3, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; - let __v_74: G = __r_arr[0]; - let __v_75: G = __r_arr[1]; - let __v_76: G = G::from_u64(1); - let __v_77: G = (__v_5 + __v_76); - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_74, __v_75, __v_2, __v_3, __v_36, __v_77, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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[181].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; - let __v_78: G = __r_arr[0]; - let __v_79: G = __r_arr[1]; - let __ret: [G; OUT_181] = [__v_78, __v_79]; - record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); - return Ok(__ret); + let __v_72: G = __r_arr[2]; + let __v_73: G = __r_arr[3]; + let __v_74: G = G::from_u64(1); + let __v_75: G = (__v_74 - __v_6); + let __v_76: G = (__v_5 + __v_75); + match __v_76.as_canonical_u64() { + 0u64 => { + let __v_77: G = (__v_7 + __v_7); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_35, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_78: G = __r_arr[0]; + let __v_79: G = __r_arr[1]; + let __v_80: G = G::from_u64(1); + let __v_81: G = (__v_7 + __v_80); + let __v_82: G = (__v_7 + __v_81); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_35, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_83: G = __r_arr[0]; + let __v_84: G = __r_arr[1]; + let __v_85: G = G::from_u64(0); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_36, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_86: G = __r_arr[0]; + let __v_87: G = __r_arr[1]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_86, __v_87, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_88: G = __r_arr[0]; + let __v_89: G = __r_arr[1]; + let __v_90: G = G::from_u64(1); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_36, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_91: G = __r_arr[0]; + let __v_92: G = __r_arr[1]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_91, __v_92, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_93: G = __r_arr[0]; + let __v_94: G = __r_arr[1]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_88, __v_89, __v_78, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_95: G = __r_arr[0]; + let __v_96: G = __r_arr[1]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_93, __v_94, __v_83, __v_84]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_97: G = __r_arr[0]; + let __v_98: G = __r_arr[1]; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_70, __v_71, __v_72, __v_73, __v_95, __v_96, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __v_99: G = __r_arr[0]; + let __v_100: G = __r_arr[1]; + let __v_101: G = __r_arr[2]; + let __v_102: G = __r_arr[3]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_99, __v_100, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_103: G = __r_arr[0]; + let __v_104: G = __r_arr[1]; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_0, __v_1, __v_2, __v_3, __v_103, __v_104]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __v_105: G = __r_arr[0]; + let __v_106: G = __r_arr[1]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_101, __v_102, __v_68, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_107: G = __r_arr[0]; + let __v_108: G = __r_arr[1]; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_105, __v_106, __v_2, __v_3, __v_107, __v_108]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __v_110: G = __r_arr[1]; + let __ret: [G; OUT_182] = [__v_109, __v_110]; + record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_77: G = G::from_u64(1); + let __v_78: G = (__v_8 - __v_77); + match __v_78.as_canonical_u64() { + 0u64 => { + let __v_79: G = (__v_7 + __v_7); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_35, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_80: G = __r_arr[0]; + let __v_81: G = __r_arr[1]; + let __v_82: G = G::from_u64(1); + let __v_83: G = (__v_7 + __v_82); + let __v_84: G = (__v_7 + __v_83); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_35, __v_84]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_85: G = __r_arr[0]; + let __v_86: G = __r_arr[1]; + let __v_87: G = G::from_u64(2); + let __v_88: G = (__v_7 + __v_87); + let __v_89: G = (__v_7 + __v_88); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_35, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_90: G = __r_arr[0]; + let __v_91: G = __r_arr[1]; + let __v_92: G = G::from_u64(3); + let __v_93: G = (__v_7 + __v_92); + let __v_94: G = (__v_7 + __v_93); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_35, __v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_95: G = __r_arr[0]; + let __v_96: G = __r_arr[1]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_90, __v_91, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_97: G = __r_arr[0]; + let __v_98: G = __r_arr[1]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_95, __v_96, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_99: G = __r_arr[0]; + let __v_100: G = __r_arr[1]; + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_70, __v_71, __v_72, __v_73, __v_97, __v_98, __v_99, __v_100]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_180] = unsafe { *(result.output.as_ptr() as *const [G; OUT_180]) }; __ret } else { aiur_fn_180(__args, record, io_buffer, __cu)? } }; + let __v_101: G = __r_arr[0]; + let __v_102: G = __r_arr[1]; + let __v_103: G = __r_arr[2]; + let __v_104: G = __r_arr[3]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_101, __v_102, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_105: G = __r_arr[0]; + let __v_106: G = __r_arr[1]; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_0, __v_1, __v_2, __v_3, __v_105, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __v_107: G = __r_arr[0]; + let __v_108: G = __r_arr[1]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_103, __v_104, __v_68, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __v_110: G = __r_arr[1]; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_107, __v_108, __v_2, __v_3, __v_109, __v_110]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __v_111: G = __r_arr[0]; + let __v_112: G = __r_arr[1]; + let __v_113: G = G::from_u64(1); + let __v_114: G = (__v_5 + __v_113); + let __v_115: G = G::from_u64(1); + let __v_116: G = (__v_7 + __v_115); + let __v_117: G = G::from_u64(1); + let __v_118: G = G::from_u64(0); + let __v_119: G = G::from_u64(0); + let __v_120: G = G::from_u64(0); + let __v_121: G = G::from_u64(0); + let __v_122: G = G::from_u64(0); + let __v_123: G = G::from_u64(0); + let __v_124: G = G::from_u64(0); + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_111, __v_112, __v_2, __v_3, __v_47, __v_114, __v_6, __v_116, __v_9, __v_9, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !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_125: G = __r_arr[0]; + let __v_126: G = __r_arr[1]; + let __ret: [G; OUT_182] = [__v_125, __v_126]; + record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_79: G = G::from_u64(1); + let __v_80: G = (__v_5 + __v_79); + let __v_81: G = G::from_u64(1); + let __v_82: G = (__v_8 - __v_81); + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_2, __v_3, __v_47, __v_80, __v_6, __v_7, __v_82, __v_9, __v_70, __v_71, __v_72, __v_73, __v_64, __v_65, __v_68, __v_69, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !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_83: G = __r_arr[0]; + let __v_84: G = __r_arr[1]; + let __ret: [G; OUT_182] = [__v_83, __v_84]; + record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_33.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); }, } }) } -const INPUT_SIZE_182: usize = 19; -const IN_182: usize = 19; -const OUT_182: usize = 2; -fn aiur_fn_182( - inp: [G; IN_182], +const INPUT_SIZE_183: usize = 20; +const IN_183: usize = 20; +const OUT_183: usize = 2; +fn aiur_fn_183( + inp: [G; IN_183], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_182], ExecError> { +) -> Result<[G; OUT_183], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14806,135 +14985,145 @@ fn aiur_fn_182( let __v_16: G = inp[16]; let __v_17: G = inp[17]; let __v_18: G = inp[18]; - let __v_19: G = G::from_u64(0); + let __v_19: G = inp[19]; let __v_20: G = G::from_u64(0); - let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = [__v_19, __v_20, __v_16, __v_17, __v_1, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[178].get_mut(&__args[..]) { 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_21: G = __r_arr[0]; - let __v_22: G = __r_arr[1]; - let __v_23: G = G::from_u64(0); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_24: G = __r_arr[0]; - let __v_25: G = __r_arr[1]; - let __v_26: G = G::from_u64(1); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_27: G = __r_arr[0]; - let __v_28: G = __r_arr[1]; - let __v_29: G = G::from_u64(2); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_30: G = __r_arr[0]; - let __v_31: G = __r_arr[1]; - let __v_32: G = G::from_u64(3); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_33: G = __r_arr[0]; - let __v_34: G = __r_arr[1]; - let __v_35: G = G::from_u64(4); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_36: G = __r_arr[0]; - let __v_37: G = __r_arr[1]; - let __v_38: G = G::from_u64(5); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_39: G = __r_arr[0]; - let __v_40: G = __r_arr[1]; - let __v_41: G = G::from_u64(6); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_42: G = __r_arr[0]; - let __v_43: G = __r_arr[1]; - let __v_44: G = G::from_u64(7); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_9, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_45: G = __r_arr[0]; - let __v_46: G = __r_arr[1]; - let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_42, __v_43, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; - let __v_47: G = __r_arr[0]; - let __v_48: G = __r_arr[1]; - let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_47, __v_48, __v_18, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __v_50: G = __r_arr[0]; - let __v_51: G = __r_arr[1]; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_12, __v_13, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __v_52: G = __r_arr[0]; - let __v_53: G = __r_arr[1]; - let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_45, __v_46, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; - let __v_54: G = __r_arr[0]; - let __v_55: G = __r_arr[1]; - let __v_56: G = G::from_u64(0); - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_54, __v_55, __v_18, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __v_57: G = __r_arr[0]; - let __v_58: G = __r_arr[1]; - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_12, __v_13, __v_57, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __v_59: G = __r_arr[0]; - let __v_60: G = __r_arr[1]; + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_20, __v_21, __v_17, __v_18, __v_1, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_179] = unsafe { *(result.output.as_ptr() as *const [G; OUT_179]) }; __ret } else { aiur_fn_179(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = __r_arr[1]; + let __v_24: G = G::from_u64(0); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + let __v_27: G = G::from_u64(1); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = G::from_u64(2); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = G::from_u64(3); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = G::from_u64(4); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = G::from_u64(5); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = __r_arr[1]; + let __v_42: G = G::from_u64(6); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __v_45: G = G::from_u64(7); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __v_47: G = __r_arr[1]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_43, __v_44, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = __r_arr[1]; + let __v_50: G = G::from_u64(0); + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_48, __v_49, __v_19, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = __r_arr[1]; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_13, __v_14, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_46, __v_47, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __v_57: G = G::from_u64(0); + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_55, __v_56, __v_19, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = __r_arr[1]; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_13, __v_14, __v_58, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = __r_arr[1]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; - let __v_61: G = __loaded[0]; - let __v_62: G = __loaded[1]; - let __v_63: G = __loaded[2]; - let __v_64: G = __loaded[3]; - match __v_61.as_canonical_u64() { + let __v_62: G = __loaded[0]; + let __v_63: G = __loaded[1]; + let __v_64: G = __loaded[2]; + let __v_65: G = __loaded[3]; + match __v_62.as_canonical_u64() { 1u64 => { - let __v_65: G = G::from_u64(0); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_66: G = __r_arr[0]; - let __v_67: G = __r_arr[1]; - let __v_68: G = G::from_u64(0); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_69: G = __r_arr[0]; - let __v_70: G = __r_arr[1]; - let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_66, __v_67, __v_69, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; - let __v_71: G = __r_arr[0]; - let __v_72: G = __r_arr[1]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_71, __v_72, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; - let __v_73: G = __r_arr[0]; - let __v_74: G = __r_arr[1]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_21, __v_22, __v_16, __v_17, __v_73, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; - let __v_75: G = __r_arr[0]; - let __v_76: G = __r_arr[1]; - let __v_77: G = G::from_u64(1); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_8, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_78: G = __r_arr[0]; - let __v_79: G = __r_arr[1]; - let __v_80: G = G::from_u64(1); - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_7, __v_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; - let __v_81: G = __r_arr[0]; - let __v_82: G = __r_arr[1]; - let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_78, __v_79, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; - let __v_83: G = __r_arr[0]; - let __v_84: G = __r_arr[1]; - let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_83, __v_84, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; - let __v_85: G = __r_arr[0]; - let __v_86: G = __r_arr[1]; - let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_75, __v_76, __v_16, __v_17, __v_85, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; - let __v_87: G = __r_arr[0]; - let __v_88: G = __r_arr[1]; - let __ret: [G; OUT_182] = [__v_87, __v_88]; - record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_66: G = G::from_u64(0); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __v_68: G = __r_arr[1]; + let __v_69: G = G::from_u64(0); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_8, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __v_71: G = __r_arr[1]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_67, __v_68, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_72: G = __r_arr[0]; + let __v_73: G = __r_arr[1]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_72, __v_73, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __v_75: G = __r_arr[1]; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_22, __v_23, __v_17, __v_18, __v_74, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __v_77: G = __r_arr[1]; + let __v_78: G = G::from_u64(1); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_79: G = __r_arr[0]; + let __v_80: G = __r_arr[1]; + let __v_81: G = G::from_u64(1); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_8, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_82: G = __r_arr[0]; + let __v_83: G = __r_arr[1]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_79, __v_80, __v_82, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __v_85: G = __r_arr[1]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_84, __v_85, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_86: G = __r_arr[0]; + let __v_87: G = __r_arr[1]; + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_76, __v_77, __v_17, __v_18, __v_86, __v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __v_88: G = __r_arr[0]; + let __v_89: G = __r_arr[1]; + let __ret: [G; OUT_183] = [__v_88, __v_89]; + record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __v_65: G = G::from_u64(0); - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; - let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_21, __v_22, __v_16, __v_17, __v_2, __v_65, __v_66, __v_52, __v_53, __v_59, __v_60, __v_24, __v_25, __v_27, __v_28, __v_30, __v_31, __v_33, __v_34, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_181] = unsafe { *(result.output.as_ptr() as *const [G; OUT_181]) }; __ret } else { aiur_fn_181(__args, record, io_buffer, __cu)? } }; + let __v_66: G = G::from_u64(0); + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !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_67: G = __r_arr[0]; - let __v_68: G = __r_arr[1]; - let __ret: [G; OUT_182] = [__v_67, __v_68]; - record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(1); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_22, __v_23, __v_17, __v_18, __v_2, __v_66, __v_67, __v_68, __v_3, __v_3, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_53, __v_54, __v_60, __v_61, __v_25, __v_26, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __v_78: G = __r_arr[1]; + let __ret: [G; OUT_183] = [__v_77, __v_78]; + record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_62.as_canonical_u64())); }, } }) } -const INPUT_SIZE_183: usize = 8; -const IN_183: usize = 8; -const OUT_183: usize = 1; -fn aiur_fn_183( - inp: [G; IN_183], +const INPUT_SIZE_184: usize = 8; +const IN_184: usize = 8; +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_183], ExecError> { +) -> Result<[G; OUT_184], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -14971,21 +15160,21 @@ fn aiur_fn_183( let __v_32: G = { let __values: [G; 4] = [__v_12, __v_2, __v_13, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_33: G = { let __values: [G; 4] = [__v_10, __v_1, __v_11, __v_32]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; let __v_34: G = { let __values: [G; 4] = [__v_8, __v_0, __v_9, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_183] = [__v_34]; - record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_184] = [__v_34]; + record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_184: usize = 5; -const IN_184: usize = 5; -const OUT_184: usize = 2; -fn aiur_fn_184( - inp: [G; IN_184], +const INPUT_SIZE_185: usize = 5; +const IN_185: usize = 5; +const OUT_185: usize = 2; +fn aiur_fn_185( + inp: [G; IN_185], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_184], ExecError> { +) -> Result<[G; OUT_185], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15001,8 +15190,8 @@ fn aiur_fn_184( 1u64 => { let __v_9: G = G::from_u64(0); let __v_10: G = G::from_u64(0); - let __ret: [G; OUT_184] = [__v_9, __v_10]; - record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_185] = [__v_9, __v_10]; + record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -15012,14 +15201,14 @@ fn aiur_fn_184( let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_3, __v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_8, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_8, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_9, __v_10, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; - let __ret: [G; OUT_184] = [__v_15, __v_16]; - record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_185] = [__v_15, __v_16]; + record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -15029,145 +15218,145 @@ fn aiur_fn_184( }) } -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_186: usize = 1; +const IN_186: usize = 1; +const OUT_186: usize = 1; +fn aiur_fn_186( + inp: [G; IN_186], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_185], ExecError> { +) -> Result<[G; OUT_186], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; match __v_0.as_canonical_u64() { 0u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 2u64 => { let __v_1: G = G::from_u64(1); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 3u64 => { let __v_1: G = G::from_u64(2); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 4u64 => { let __v_1: G = G::from_u64(4); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 5u64 => { let __v_1: G = G::from_u64(4); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 6u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 7u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 8u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 9u64 => { let __v_1: G = G::from_u64(8); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 10u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 11u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 12u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 13u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 14u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 15u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 16u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 17u64 => { let __v_1: G = G::from_u64(16); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_1: G = G::from_u64(32); - let __ret: [G; OUT_185] = [__v_1]; - record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_186] = [__v_1]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_186: usize = 4; -const IN_186: usize = 4; -const OUT_186: usize = 2; -fn aiur_fn_186( - inp: [G; IN_186], +const INPUT_SIZE_187: usize = 4; +const IN_187: usize = 4; +const OUT_187: usize = 2; +fn aiur_fn_187( + inp: [G; IN_187], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_186], ExecError> { +) -> Result<[G; OUT_187], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15181,8 +15370,8 @@ fn aiur_fn_186( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_6, __v_9]; - record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_187] = [__v_6, __v_9]; + record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { @@ -15194,21 +15383,21 @@ fn aiur_fn_186( let __v_7: G = G::from_u64(1); let __v_8: G = G::from_u64(1); let __v_9: G = { let __values: [G; 4] = [__v_7, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_186] = [__v_6, __v_9]; - record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_187] = [__v_6, __v_9]; + record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 1u64 => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = G::from_u64(1); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_186] = [__v_6, __v_8]; - record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_187] = [__v_6, __v_8]; + record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -15223,15 +15412,15 @@ fn aiur_fn_186( }) } -const INPUT_SIZE_187: usize = 20; -const IN_187: usize = 20; -const OUT_187: usize = 1; -fn aiur_fn_187( - inp: [G; IN_187], +const INPUT_SIZE_188: usize = 20; +const IN_188: usize = 20; +const OUT_188: usize = 1; +fn aiur_fn_188( + inp: [G; IN_188], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_187], ExecError> { +) -> Result<[G; OUT_188], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15253,7 +15442,7 @@ fn aiur_fn_187( let __v_17: G = inp[17]; let __v_18: G = inp[18]; let __v_19: G = inp[19]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_20: G = __loaded[0]; let __v_21: G = __loaded[1]; let __v_22: G = __loaded[2]; @@ -15261,104 +15450,105 @@ fn aiur_fn_187( let __v_24: G = __loaded[4]; let __v_25: G = __loaded[5]; let __v_26: G = __loaded[6]; + let __v_27: G = __loaded[7]; match __v_20.as_canonical_u64() { 1u64 => { - let __v_27: G = G::from_u64(1); - let __ret: [G; OUT_187] = [__v_27]; - record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_28: G = G::from_u64(1); + let __ret: [G; OUT_188] = [__v_28]; + record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { match __v_21.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_27: G = __r_arr[0]; - let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_28: G = __r_arr[0]; - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; let __v_29: G = __r_arr[0]; - let __v_30: G = __r_arr[1]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_31: G = __r_arr[0]; - let __v_32: G = G::from_u64(0); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_33: G = __r_arr[0]; - let __v_34: G = G::from_u64(1); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_31, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_35: G = __r_arr[0]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = G::from_u64(0); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_32, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = G::from_u64(1); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_32, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __v_37: G = G::from_u64(0); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_38: G = __r_arr[0]; - let __v_39: G = G::from_u64(1); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_36, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_40: G = __r_arr[0]; - let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_201] = unsafe { *(result.output.as_ptr() as *const [G; OUT_201]) }; __ret } else { aiur_fn_201(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = G::from_u64(0); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = G::from_u64(1); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_37, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_41: G = __r_arr[0]; - let __v_42: G = __r_arr[1]; - let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_6, __v_7, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_186] = unsafe { *(result.output.as_ptr() as *const [G; OUT_186]) }; __ret } else { aiur_fn_186(__args, record, io_buffer, __cu)? } }; - let __v_43: G = __r_arr[0]; - let __v_44: G = __r_arr[1]; - let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_18, __v_19, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; - let __v_45: G = __r_arr[0]; - let __v_46: G = __r_arr[1]; - let __v_47: G = __r_arr[2]; - let __v_48: G = __r_arr[3]; - let __v_49: G = __r_arr[4]; - let __v_50: G = __r_arr[5]; - let __v_51: G = __r_arr[6]; - let __v_52: G = __r_arr[7]; - let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_12, __v_13, __v_14, __v_15, __v_10, __v_11, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; - let __v_53: G = __r_arr[0]; - let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[171].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __v_43: G = __r_arr[1]; + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_6, __v_7, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __v_47: G = __r_arr[1]; + let __v_48: G = __r_arr[2]; + let __v_49: G = __r_arr[3]; + let __v_50: G = __r_arr[4]; + let __v_51: G = __r_arr[5]; + let __v_52: G = __r_arr[6]; + let __v_53: G = __r_arr[7]; + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12, __v_13, __v_14, __v_15, __v_10, __v_11, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; - let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; let __v_55: G = __r_arr[0]; - let __v_56: G = (__v_54 * __v_55); - let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; - let __v_57: G = __r_arr[0]; - let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_21, __v_23, __v_25, __v_33, __v_35, __v_43, __v_44, __v_38, __v_40, __v_53, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_16, __v_17, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = (__v_55 * __v_56); + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_16] = unsafe { *(result.output.as_ptr() as *const [G; OUT_16]) }; __ret } else { aiur_fn_16(__args, record, io_buffer, __cu)? } }; let __v_58: G = __r_arr[0]; - let __v_59: G = __r_arr[1]; - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_60: G = __r_arr[0]; - let __v_61: G = G::from_u64(0); - let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; - let __v_62: G = __r_arr[0]; - let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_21, __v_23, __v_25, __v_26, __v_34, __v_36, __v_44, __v_45, __v_39, __v_41, __v_54, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_16, __v_17, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !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_61: G = __r_arr[0]; + let __v_62: G = G::from_u64(0); + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; let __v_63: G = __r_arr[0]; - let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_18, __v_19, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_177] = unsafe { *(result.output.as_ptr() as *const [G; OUT_177]) }; __ret } else { aiur_fn_177(__args, record, io_buffer, __cu)? } }; let __v_64: G = __r_arr[0]; - let __v_65: G = __r_arr[1]; - let __v_66: G = G::from_u64(1); - let __v_67: G = G::from_u64(0); - let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; - let __v_68: G = __r_arr[0]; - let __v_69: G = __r_arr[1]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; - let __v_70: G = __r_arr[0]; - let __v_71: G = (__v_70 - __v_28); - let __v_72: G = G::from_bool((__v_71 == G::ZERO)); - let __v_73: G = G::from_u64(1); - if (__v_72 != __v_73) { - return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_73.as_canonical_u64() }); - } - let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_58, __v_59, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; - let __v_74: G = __r_arr[0]; - let __v_75: G = __r_arr[1]; - let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_74, __v_75, __v_68, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; - let __v_76: G = __r_arr[0]; - let __v_77: G = G::from_u64(1); - if (__v_76 != __v_77) { - return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_77.as_canonical_u64() }); + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_18, __v_19, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_169] = unsafe { *(result.output.as_ptr() as *const [G; OUT_169]) }; __ret } else { aiur_fn_169(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __v_66: G = __r_arr[1]; + let __v_67: G = G::from_u64(1); + let __v_68: G = G::from_u64(0); + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_185] = unsafe { *(result.output.as_ptr() as *const [G; OUT_185]) }; __ret } else { aiur_fn_185(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __v_70: G = __r_arr[1]; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __v_72: G = (__v_71 - __v_29); + let __v_73: G = G::from_bool((__v_72 == G::ZERO)); + let __v_74: G = G::from_u64(1); + if (__v_73 != __v_74) { + return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_74.as_canonical_u64() }); } + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_59, __v_60, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __v_76: G = __r_arr[1]; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_75, __v_76, __v_69, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; let __v_78: G = G::from_u64(1); - let __v_79: G = (__v_9 + __v_78); - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_26, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_79, __v_29, __v_30, __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[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; - let __v_80: G = __r_arr[0]; - let __ret: [G; OUT_187] = [__v_80]; - record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + if (__v_77 != __v_78) { + return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_78.as_canonical_u64() }); + } + let __v_79: G = G::from_u64(1); + let __v_80: G = (__v_9 + __v_79); + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_80, __v_30, __v_31, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __v_81: G = __r_arr[0]; + let __ret: [G; OUT_188] = [__v_81]; + record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -15370,15 +15560,15 @@ fn aiur_fn_187( }) } -const INPUT_SIZE_188: usize = 3; -const IN_188: usize = 3; -const OUT_188: usize = 2; -fn aiur_fn_188( - inp: [G; IN_188], +const INPUT_SIZE_189: usize = 3; +const IN_189: usize = 3; +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_188], ExecError> { +) -> Result<[G; OUT_189], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15398,15 +15588,15 @@ fn aiur_fn_188( 1u64 => { let __v_13: G = G::from_u64(0); let __v_14: G = G::from_u64(0); - let __ret: [G; OUT_188] = [__v_13, __v_14]; - record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_189] = [__v_13, __v_14]; + record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = G::from_u64(0); - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; let __v_15: G = __r_arr[0]; let __v_16: G = __r_arr[1]; let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_0, __v_1, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; @@ -15415,8 +15605,8 @@ fn aiur_fn_188( let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_13, __v_14, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_19: G = __r_arr[0]; let __v_20: G = __r_arr[1]; - let __ret: [G; OUT_188] = [__v_19, __v_20]; - record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_189] = [__v_19, __v_20]; + record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -15426,15 +15616,15 @@ fn aiur_fn_188( }) } -const INPUT_SIZE_189: usize = 7; -const IN_189: usize = 7; -const OUT_189: usize = 2; -fn aiur_fn_189( - inp: [G; IN_189], +const INPUT_SIZE_190: usize = 7; +const IN_190: usize = 7; +const OUT_190: usize = 2; +fn aiur_fn_190( + inp: [G; IN_190], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_189], ExecError> { +) -> Result<[G; OUT_190], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15449,12 +15639,12 @@ fn aiur_fn_189( let __v_9: G = __loaded[2]; match __v_7.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_189] = [__v_0, __v_1]; - record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_190] = [__v_0, __v_1]; + record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_5, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = __r_arr[1]; let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_3, __v_4, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; @@ -15466,11 +15656,11 @@ fn aiur_fn_189( let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0, __v_1, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; let __v_16: G = __r_arr[0]; let __v_17: G = __r_arr[1]; - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_16, __v_17, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_16, __v_17, __v_9, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_18: G = __r_arr[0]; let __v_19: G = __r_arr[1]; - let __ret: [G; OUT_189] = [__v_18, __v_19]; - record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_190] = [__v_18, __v_19]; + record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -15480,15 +15670,15 @@ fn aiur_fn_189( }) } -const INPUT_SIZE_190: usize = 36; -const IN_190: usize = 36; -const OUT_190: usize = 1; -fn aiur_fn_190( - inp: [G; IN_190], +const INPUT_SIZE_191: usize = 36; +const IN_191: usize = 36; +const OUT_191: usize = 1; +fn aiur_fn_191( + inp: [G; IN_191], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_190], ExecError> { +) -> Result<[G; OUT_191], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15532,15 +15722,15 @@ fn aiur_fn_190( _ => { match __v_12.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; let __v_36: G = __r_arr[0]; - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_37: G = __r_arr[0]; match __v_13.as_canonical_u64() { _ => { - let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_166] = unsafe { *(result.output.as_ptr() as *const [G; OUT_166]) }; __ret } else { aiur_fn_166(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; let __v_38: G = __r_arr[0]; - let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__v_7, __v_12, __v_38, __v_13, __v_14, __v_15, __v_17, __v_35, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_167] = unsafe { *(result.output.as_ptr() as *const [G; OUT_167]) }; __ret } else { aiur_fn_167(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_7, __v_12, __v_38, __v_13, __v_14, __v_15, __v_17, __v_35, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_168] = unsafe { *(result.output.as_ptr() as *const [G; OUT_168]) }; __ret } else { aiur_fn_168(__args, record, io_buffer, __cu)? } }; let __v_39: G = __r_arr[0]; let __v_40: G = __r_arr[1]; let __v_41: G = __r_arr[2]; @@ -15552,21 +15742,21 @@ fn aiur_fn_190( let __v_47: G = __r_arr[8]; let __v_48: G = G::from_u64(0); let __v_49: G = G::from_u64(0); - let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_48, __v_49, __v_35, __v_39, __v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_189] = unsafe { *(result.output.as_ptr() as *const [G; OUT_189]) }; __ret } else { aiur_fn_189(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_48, __v_49, __v_35, __v_39, __v_40, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; let __v_50: G = __r_arr[0]; let __v_51: G = __r_arr[1]; let __v_52: G = G::from_u64(0); - let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_36, __v_37, __v_17, __v_16, __v_33, __v_34, __v_31, __v_32, __v_30, __v_52, __v_50, __v_51, __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[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_36, __v_37, __v_17, __v_16, __v_33, __v_34, __v_31, __v_32, __v_30, __v_52, __v_50, __v_51, __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[188].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_188] = unsafe { *(result.output.as_ptr() as *const [G; OUT_188]) }; __ret } else { aiur_fn_188(__args, record, io_buffer, __cu)? } }; let __v_53: G = __r_arr[0]; - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_54: G = __r_arr[0]; let __v_55: G = G::from_u64(1); if (__v_54 != __v_55) { return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_55.as_canonical_u64() }); } - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_56: G = __r_arr[0]; - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_57: G = __r_arr[0]; let __v_58: G = (__v_56 - __v_57); let __v_59: G = G::from_bool((__v_58 == G::ZERO)); @@ -15574,9 +15764,9 @@ fn aiur_fn_190( if (__v_59 != __v_60) { return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_60.as_canonical_u64() }); } - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_61: G = __r_arr[0]; - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !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_62: G = __r_arr[0]; let __v_63: G = (__v_61 - __v_62); let __v_64: G = G::from_bool((__v_63 == G::ZERO)); @@ -15584,12 +15774,12 @@ fn aiur_fn_190( if (__v_64 != __v_65) { return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_65.as_canonical_u64() }); } - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; let __v_66: G = __r_arr[0]; - let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_47, __v_33, __v_34, __v_30, __v_31, __v_32, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_13, __v_14, __v_15, __v_38, __v_37, __v_17, __v_45, __v_46, __v_66, __v_0, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_146] = unsafe { *(result.output.as_ptr() as *const [G; OUT_146]) }; __ret } else { aiur_fn_146(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_47, __v_33, __v_34, __v_30, __v_31, __v_32, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_13, __v_14, __v_15, __v_38, __v_37, __v_17, __v_45, __v_46, __v_66, __v_0, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_147] = unsafe { *(result.output.as_ptr() as *const [G; OUT_147]) }; __ret } else { aiur_fn_147(__args, record, io_buffer, __cu)? } }; let __v_67: G = __r_arr[0]; - let __ret: [G; OUT_190] = [__v_67]; - record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_191] = [__v_67]; + record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -15602,15 +15792,15 @@ fn aiur_fn_190( }) } -const INPUT_SIZE_191: usize = 1; -const IN_191: usize = 1; -const OUT_191: usize = 1; -fn aiur_fn_191( - inp: [G; IN_191], +const INPUT_SIZE_192: usize = 1; +const IN_192: usize = 1; +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_191], ExecError> { +) -> Result<[G; OUT_192], 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 }; @@ -15620,8 +15810,8 @@ fn aiur_fn_191( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_191] = [__v_4]; - record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_192] = [__v_4]; + record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -15632,10 +15822,10 @@ fn aiur_fn_191( if (__v_6 != __v_7) { return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64() }); } - let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; - let __ret: [G; OUT_191] = [__v_8]; - record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_192] = [__v_8]; + record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -15645,19 +15835,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_193: usize = 2; +const IN_193: usize = 2; +const OUT_193: usize = 1; +fn aiur_fn_193( + inp: [G; IN_193], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_192], ExecError> { +) -> Result<[G; OUT_193], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; let __v_2: G = __loaded[0]; let __v_3: G = __loaded[1]; let __v_4: G = __loaded[2]; @@ -15665,43 +15855,44 @@ fn aiur_fn_192( let __v_6: G = __loaded[4]; let __v_7: G = __loaded[5]; let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; match __v_2.as_canonical_u64() { 1u64 => { - let __v_9: G = G::from_u64(1); let __v_10: G = G::from_u64(1); - let __v_11: G = { let __values: [G; 7] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_192] = [__v_11]; - record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 8] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_193] = [__v_12]; + record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; - let __v_9: G = __loaded[0]; - let __v_10: G = __loaded[1]; - let __v_11: G = __loaded[2]; - match __v_9.as_canonical_u64() { + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { 0u64 => { - match __v_10.as_canonical_u64() { + match __v_11.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; - let __v_12: G = __r_arr[0]; - let __ret: [G; OUT_192] = [__v_12]; - record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_193] = [__v_13]; + record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; - let __v_13: G = __r_arr[0]; - let __v_14: G = { let __values: [G; 7] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_13]; let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_192] = [__v_14]; - record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = { let __values: [G; 8] = [__v_13, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_193] = [__v_15]; + record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }, _ => { - return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); }, } }, @@ -15712,15 +15903,15 @@ 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_194: usize = 2; +const IN_194: usize = 2; +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_193], ExecError> { +) -> Result<[G; OUT_194], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15734,8 +15925,8 @@ fn aiur_fn_193( 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_193] = [__v_8]; - record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_194] = [__v_8]; + record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { @@ -15747,19 +15938,19 @@ fn aiur_fn_193( 0u64 => { match __v_7.as_canonical_u64() { 0u64 => { - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_9: G = __r_arr[0]; - let __ret: [G; OUT_193] = [__v_9]; - record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_194] = [__v_9]; + record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_9: G = G::from_u64(0); - let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; let __v_10: G = __r_arr[0]; let __v_11: G = { let __values: [G; 4] = [__v_9, __v_3, __v_4, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_193] = [__v_11]; - record.function_queries[193].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_194] = [__v_11]; + record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } @@ -15776,38 +15967,38 @@ fn aiur_fn_193( }) } -const INPUT_SIZE_194: usize = 1; -const IN_194: usize = 1; -const OUT_194: usize = 2; -fn aiur_fn_194( - inp: [G; IN_194], +const INPUT_SIZE_195: usize = 1; +const IN_195: usize = 1; +const OUT_195: usize = 2; +fn aiur_fn_195( + inp: [G; IN_195], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_194], ExecError> { +) -> Result<[G; OUT_195], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_194] = [__v_3, __v_4]; - record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_195] = [__v_3, __v_4]; + record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_195: usize = 2; -const IN_195: usize = 2; -const OUT_195: usize = 2; -fn aiur_fn_195( - inp: [G; IN_195], +const INPUT_SIZE_196: usize = 2; +const IN_196: usize = 2; +const OUT_196: usize = 2; +fn aiur_fn_196( + inp: [G; IN_196], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_195], ExecError> { +) -> Result<[G; OUT_196], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15816,61 +16007,61 @@ fn aiur_fn_195( 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_195] = [__v_4, __v_0]; - record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_196] = [__v_4, __v_0]; + record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { - let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __v_3: G = __r_arr[1]; let __v_4: G = G::from_u64(1); let __v_5: G = (__v_1 - __v_4); - let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = __r_arr[1]; let __v_8: G = G::from_u64(0); let __v_9: G = { let __values: [G; 3] = [__v_8, __v_2, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_195] = [__v_9, __v_7]; - record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_196] = [__v_9, __v_7]; + record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } -const INPUT_SIZE_196: usize = 1; -const IN_196: usize = 1; -const OUT_196: usize = 2; -fn aiur_fn_196( - inp: [G; IN_196], +const INPUT_SIZE_197: usize = 1; +const IN_197: usize = 1; +const OUT_197: usize = 2; +fn aiur_fn_197( + inp: [G; IN_197], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_196], ExecError> { +) -> Result<[G; OUT_197], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_26] = unsafe { *(result.output.as_ptr() as *const [G; OUT_26]) }; __ret } else { aiur_fn_26(__args, record, io_buffer, __cu)? } }; let __v_1: G = __r_arr[0]; let __v_2: G = __r_arr[1]; - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_3: G = __r_arr[0]; let __v_4: G = __r_arr[1]; - let __ret: [G; OUT_196] = [__v_3, __v_4]; - record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_197] = [__v_3, __v_4]; + record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_197: usize = 2; -const IN_197: usize = 2; -const OUT_197: usize = 2; -fn aiur_fn_197( - inp: [G; IN_197], +const INPUT_SIZE_198: usize = 2; +const IN_198: usize = 2; +const OUT_198: usize = 2; +fn aiur_fn_198( + inp: [G; IN_198], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_197], ExecError> { +) -> Result<[G; OUT_198], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -15879,8 +16070,8 @@ fn aiur_fn_197( let __v_2: G = G::from_u64(1); let __v_3: G = G::from_u64(1); let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_4, __v_0]; - record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_198] = [__v_4, __v_0]; + record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -15896,28 +16087,28 @@ fn aiur_fn_197( let __v_10: G = __r_arr[8]; let __v_11: G = G::from_u64(1); let __v_12: G = (__v_1 - __v_11); - let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = __r_arr[1]; let __v_15: G = G::from_u64(0); let __v_16: G = { let __values: [G; 10] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_197] = [__v_16, __v_14]; - record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_198] = [__v_16, __v_14]; + record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, } }) } - -const INPUT_SIZE_198: usize = 64; -const IN_198: usize = 64; -const OUT_198: usize = 0; -fn aiur_fn_198( - inp: [G; IN_198], + +const INPUT_SIZE_199: usize = 64; +const IN_199: usize = 64; +const OUT_199: usize = 0; +fn aiur_fn_199( + inp: [G; IN_199], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_198], ExecError> { +) -> Result<[G; OUT_199], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16018,7 +16209,7 @@ fn aiur_fn_198( let __io_pair: (G, G) = { let __key: [G; 1] = [__v_93]; let __info = io_buffer.get_info(__v_92, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; let __v_94: G = __io_pair.0; let __v_95: G = __io_pair.1; - let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_92] = unsafe { *(result.output.as_ptr() as *const [G; OUT_92]) }; __ret } else { aiur_fn_92(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_94]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_93] = unsafe { *(result.output.as_ptr() as *const [G; OUT_93]) }; __ret } else { aiur_fn_93(__args, record, io_buffer, __cu)? } }; let __v_96: G = __r_arr[0]; let __v_97: G = __r_arr[1]; let __v_98: G = __r_arr[2]; @@ -16040,7 +16231,7 @@ fn aiur_fn_198( let __v_113: G = G::from_u64(2); let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_113, __v_111, __v_112]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; let __v_114: G = __r_arr[0]; - let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_114]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; let __v_115: G = __r_arr[0]; let __v_116: G = __r_arr[1]; let __v_117: G = (__v_66 + __v_67); @@ -16048,7 +16239,7 @@ fn aiur_fn_198( return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_117.as_canonical_u64() }); } let __v_118: G = G::from_u64(1); - let __r_arr: [G; OUT_98] = { let __args: [G; IN_98] = [__v_118, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[98].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_98] = unsafe { *(result.output.as_ptr() as *const [G; OUT_98]) }; __ret } else { aiur_fn_98(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_118, __v_94, __v_95]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; let __v_119: G = __r_arr[0]; let __v_120: G = __r_arr[1]; let __v_121: G = __r_arr[2]; @@ -16081,7 +16272,7 @@ fn aiur_fn_198( let __v_148: G = __r_arr[29]; let __v_149: G = __r_arr[30]; let __v_150: G = __r_arr[31]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_151: G = __r_arr[0]; let __v_152: G = __r_arr[1]; let __v_153: G = __r_arr[2]; @@ -16247,7 +16438,7 @@ fn aiur_fn_198( let __v_213: G = __r_arr[29]; let __v_214: G = __r_arr[30]; let __v_215: G = __r_arr[31]; - let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215]; let __cu = unconstrained; if let Some(result) = record.function_queries[96].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_96] = unsafe { *(result.output.as_ptr() as *const [G; OUT_96]) }; __ret } else { aiur_fn_96(__args, record, io_buffer, __cu)? } }; let __v_216: G = __r_arr[0]; let __v_217: G = __r_arr[1]; let __v_218: G = __r_arr[2]; @@ -16391,33 +16582,33 @@ fn aiur_fn_198( if (__v_250 != __v_252) { return Err(ExecError::AssertEqMismatch { lhs: __v_250.as_canonical_u64(), rhs: __v_252.as_canonical_u64() }); } - let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_173] = unsafe { *(result.output.as_ptr() as *const [G; OUT_173]) }; __ret } else { aiur_fn_173(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = [__v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90]; let __cu = unconstrained; if let Some(result) = record.function_queries[174].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_174] = unsafe { *(result.output.as_ptr() as *const [G; OUT_174]) }; __ret } else { aiur_fn_174(__args, record, io_buffer, __cu)? } }; let __v_253: G = __r_arr[0]; let __v_254: G = G::from_u64(1); if (__v_253 != __v_254) { return Err(ExecError::AssertEqMismatch { lhs: __v_253.as_canonical_u64(), rhs: __v_254.as_canonical_u64() }); } - let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__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_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_115]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_190] = unsafe { *(result.output.as_ptr() as *const [G; OUT_190]) }; __ret } else { aiur_fn_190(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__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_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_115]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_191] = unsafe { *(result.output.as_ptr() as *const [G; OUT_191]) }; __ret } else { aiur_fn_191(__args, record, io_buffer, __cu)? } }; let __v_255: G = __r_arr[0]; let __v_256: G = G::from_u64(1); if (__v_255 != __v_256) { return Err(ExecError::AssertEqMismatch { lhs: __v_255.as_canonical_u64(), rhs: __v_256.as_canonical_u64() }); } - let __ret: [G; OUT_198] = []; - record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_199] = []; + record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }) } -const INPUT_SIZE_199: usize = 1; -const IN_199: usize = 1; -const OUT_199: usize = 1; -fn aiur_fn_199( - inp: [G; IN_199], +const INPUT_SIZE_200: usize = 1; +const IN_200: usize = 1; +const OUT_200: usize = 1; +fn aiur_fn_200( + inp: [G; IN_200], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_199], ExecError> { +) -> Result<[G; OUT_200], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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 }; @@ -16427,17 +16618,17 @@ fn aiur_fn_199( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_199] = [__v_4]; - record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_200] = [__v_4]; + record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = G::from_u64(1); let __v_6: G = (__v_4 + __v_5); - let __ret: [G; OUT_199] = [__v_6]; - record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_200] = [__v_6]; + record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16447,15 +16638,15 @@ fn aiur_fn_199( }) } -const INPUT_SIZE_200: usize = 1; -const IN_200: usize = 1; -const OUT_200: usize = 1; -fn aiur_fn_200( - inp: [G; IN_200], +const INPUT_SIZE_201: usize = 1; +const IN_201: usize = 1; +const OUT_201: usize = 1; +fn aiur_fn_201( + inp: [G; IN_201], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_200], ExecError> { +) -> Result<[G; OUT_201], 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 }; @@ -16465,14 +16656,14 @@ fn aiur_fn_200( match __v_1.as_canonical_u64() { 1u64 => { let __v_4: G = G::from_u64(1); - let __ret: [G; OUT_200] = [__v_4]; - record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_201] = [__v_4]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_4: G = G::from_u64(0); - let __ret: [G; OUT_200] = [__v_4]; - record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_201] = [__v_4]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16482,19 +16673,19 @@ fn aiur_fn_200( }) } -const INPUT_SIZE_201: usize = 2; -const IN_201: usize = 2; -const OUT_201: usize = 2; -fn aiur_fn_201( - inp: [G; IN_201], +const INPUT_SIZE_202: usize = 2; +const IN_202: usize = 2; +const OUT_202: usize = 2; +fn aiur_fn_202( + inp: [G; IN_202], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_201], ExecError> { +) -> Result<[G; OUT_202], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 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]; @@ -16503,8 +16694,8 @@ fn aiur_fn_201( let __v_6: G = __loaded[3]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_201] = [__v_4, __v_5]; - record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_202] = [__v_4, __v_5]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16514,15 +16705,15 @@ fn aiur_fn_201( }) } -const INPUT_SIZE_202: usize = 1; -const IN_202: usize = 1; -const OUT_202: usize = 8; -fn aiur_fn_202( - inp: [G; IN_202], +const INPUT_SIZE_203: usize = 1; +const IN_203: usize = 1; +const OUT_203: usize = 8; +fn aiur_fn_203( + inp: [G; IN_203], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_202], ExecError> { +) -> Result<[G; OUT_203], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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 }; @@ -16546,12 +16737,12 @@ fn aiur_fn_202( 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_202] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; - record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_203] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_203] = unsafe { *(result.output.as_ptr() as *const [G; OUT_203]) }; __ret } else { aiur_fn_203(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = __r_arr[1]; let __v_13: G = __r_arr[2]; @@ -16569,8 +16760,8 @@ fn aiur_fn_202( 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_202] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; - record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_203] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16580,19 +16771,19 @@ fn aiur_fn_202( }) } -const INPUT_SIZE_203: usize = 2; -const IN_203: usize = 2; -const OUT_203: usize = 1; -fn aiur_fn_203( - inp: [G; IN_203], +const INPUT_SIZE_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_203], ExecError> { +) -> Result<[G; OUT_204], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -16600,8 +16791,8 @@ fn aiur_fn_203( let __v_5: G = __loaded[2]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_203] = [__v_4]; - record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_204] = [__v_4]; + record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16611,15 +16802,15 @@ fn aiur_fn_203( }) } -const INPUT_SIZE_204: usize = 1; -const IN_204: usize = 1; -const OUT_204: usize = 1; -fn aiur_fn_204( - inp: [G; IN_204], +const INPUT_SIZE_205: usize = 1; +const IN_205: usize = 1; +const OUT_205: usize = 1; +fn aiur_fn_205( + inp: [G; IN_205], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_204], ExecError> { +) -> Result<[G; OUT_205], 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 }; @@ -16631,17 +16822,17 @@ fn aiur_fn_204( match __v_1.as_canonical_u64() { 1u64 => { let __v_6: G = G::from_u64(0); - let __ret: [G; OUT_204] = [__v_6]; - record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_205] = [__v_6]; + record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; let __v_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_204] = [__v_8]; - record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_205] = [__v_8]; + record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16651,15 +16842,15 @@ fn aiur_fn_204( }) } -const INPUT_SIZE_205: usize = 1; -const IN_205: usize = 1; -const OUT_205: usize = 1; -fn aiur_fn_205( - inp: [G; IN_205], +const INPUT_SIZE_206: usize = 1; +const IN_206: usize = 1; +const OUT_206: usize = 1; +fn aiur_fn_206( + inp: [G; IN_206], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_205], ExecError> { +) -> Result<[G; OUT_206], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 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 }; @@ -16670,17 +16861,17 @@ fn aiur_fn_205( match __v_1.as_canonical_u64() { 1u64 => { let __v_5: G = G::from_u64(0); - let __ret: [G; OUT_205] = [__v_5]; - record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_206] = [__v_5]; + record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; let __v_5: G = __r_arr[0]; let __v_6: G = G::from_u64(1); let __v_7: G = (__v_5 + __v_6); - let __ret: [G; OUT_205] = [__v_7]; - record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_206] = [__v_7]; + record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16690,15 +16881,15 @@ fn aiur_fn_205( }) } -const INPUT_SIZE_206: usize = 2; -const IN_206: usize = 2; -const OUT_206: usize = 1; -fn aiur_fn_206( - inp: [G; IN_206], +const INPUT_SIZE_207: usize = 2; +const IN_207: usize = 2; +const OUT_207: usize = 1; +fn aiur_fn_207( + inp: [G; IN_207], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_206], ExecError> { +) -> Result<[G; OUT_207], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16715,17 +16906,17 @@ fn aiur_fn_206( let __v_11: G = __loaded[9]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_206] = [__v_1]; - record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_207] = [__v_1]; + record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_12: G = G::from_u64(0); - let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; let __v_13: G = __r_arr[0]; let __v_14: G = { let __values: [G; 10] = [__v_12, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_206] = [__v_14]; - record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_207] = [__v_14]; + record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16735,15 +16926,15 @@ fn aiur_fn_206( }) } -const INPUT_SIZE_207: usize = 1; -const IN_207: usize = 1; -const OUT_207: usize = 8; -fn aiur_fn_207( - inp: [G; IN_207], +const INPUT_SIZE_208: usize = 1; +const IN_208: usize = 1; +const OUT_208: usize = 8; +fn aiur_fn_208( + inp: [G; IN_208], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_207], ExecError> { +) -> Result<[G; OUT_208], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __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 }; @@ -16760,12 +16951,12 @@ fn aiur_fn_207( 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_207] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; - record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_208] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __v_5: G = __r_arr[1]; let __v_6: G = __r_arr[2]; @@ -16783,8 +16974,8 @@ fn aiur_fn_207( 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_207] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; - record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_208] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16794,15 +16985,15 @@ fn aiur_fn_207( }) } -const INPUT_SIZE_208: usize = 2; -const IN_208: usize = 2; -const OUT_208: usize = 1; -fn aiur_fn_208( - inp: [G; IN_208], +const INPUT_SIZE_209: usize = 2; +const IN_209: usize = 2; +const OUT_209: usize = 1; +fn aiur_fn_209( + inp: [G; IN_209], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_208], ExecError> { +) -> Result<[G; OUT_209], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; @@ -16812,17 +17003,17 @@ fn aiur_fn_208( let __v_4: G = __loaded[2]; match __v_2.as_canonical_u64() { 1u64 => { - let __ret: [G; OUT_208] = [__v_1]; - record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_209] = [__v_1]; + record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { let __v_5: G = G::from_u64(0); - let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; let __v_6: G = __r_arr[0]; let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; - let __ret: [G; OUT_208] = [__v_7]; - record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_209] = [__v_7]; + record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16832,28 +17023,28 @@ fn aiur_fn_208( }) } -const INPUT_SIZE_209: usize = 2; -const IN_209: usize = 2; -const OUT_209: usize = 1; -fn aiur_fn_209( - inp: [G; IN_209], +const INPUT_SIZE_210: usize = 2; +const IN_210: usize = 2; +const OUT_210: usize = 1; +fn aiur_fn_210( + inp: [G; IN_210], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_209], ExecError> { +) -> Result<[G; OUT_210], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_209] = [__v_0]; - record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_210] = [__v_0]; + record.function_queries[210].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_209] = { let __args: [G; IN_209] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_209] = unsafe { *(result.output.as_ptr() as *const [G; OUT_209]) }; __ret } else { aiur_fn_209(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; let __v_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]; @@ -16861,8 +17052,8 @@ fn aiur_fn_209( let __v_7: G = __loaded[2]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_209] = [__v_7]; - record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_210] = [__v_7]; + record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16874,15 +17065,15 @@ fn aiur_fn_209( }) } -const INPUT_SIZE_210: usize = 1; -const IN_210: usize = 1; -const OUT_210: usize = 1; -fn aiur_fn_210( - inp: [G; IN_210], +const INPUT_SIZE_211: usize = 1; +const IN_211: usize = 1; +const OUT_211: usize = 1; +fn aiur_fn_211( + inp: [G; IN_211], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_210], ExecError> { +) -> Result<[G; OUT_211], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __loaded: [G; 7] = { let __mq = record.memory_queries.get_mut(&7).ok_or(ExecError::InvalidMemorySize(7))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 7 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 7] = __args[..7].try_into().unwrap(); __arr }; @@ -16896,17 +17087,17 @@ fn aiur_fn_210( match __v_1.as_canonical_u64() { 1u64 => { let __v_8: G = G::from_u64(0); - let __ret: [G; OUT_210] = [__v_8]; - record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_211] = [__v_8]; + record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_210] = unsafe { *(result.output.as_ptr() as *const [G; OUT_210]) }; __ret } else { aiur_fn_210(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; let __v_8: G = __r_arr[0]; let __v_9: G = G::from_u64(1); let __v_10: G = (__v_8 + __v_9); - let __ret: [G; OUT_210] = [__v_10]; - record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_211] = [__v_10]; + record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16916,15 +17107,15 @@ fn aiur_fn_210( }) } -const INPUT_SIZE_211: usize = 1; -const IN_211: usize = 1; -const OUT_211: usize = 1; -fn aiur_fn_211( - inp: [G; IN_211], +const INPUT_SIZE_212: usize = 1; +const IN_212: usize = 1; +const OUT_212: usize = 1; +fn aiur_fn_212( + inp: [G; IN_212], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_211], ExecError> { +) -> Result<[G; OUT_212], 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 }; @@ -16941,17 +17132,17 @@ fn aiur_fn_211( match __v_1.as_canonical_u64() { 1u64 => { let __v_11: G = G::from_u64(0); - let __ret: [G; OUT_211] = [__v_11]; - record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_212] = [__v_11]; + record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, 0u64 => { - let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_211] = unsafe { *(result.output.as_ptr() as *const [G; OUT_211]) }; __ret } else { aiur_fn_211(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; let __v_11: G = __r_arr[0]; let __v_12: G = G::from_u64(1); let __v_13: G = (__v_11 + __v_12); - let __ret: [G; OUT_211] = [__v_13]; - record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_212] = [__v_13]; + record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16961,19 +17152,19 @@ fn aiur_fn_211( }) } -const INPUT_SIZE_212: usize = 2; -const IN_212: usize = 2; -const OUT_212: usize = 4; -fn aiur_fn_212( - inp: [G; IN_212], +const INPUT_SIZE_213: usize = 2; +const IN_213: usize = 2; +const OUT_213: usize = 4; +fn aiur_fn_213( + inp: [G; IN_213], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_212], ExecError> { +) -> Result<[G; OUT_213], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -16984,8 +17175,8 @@ fn aiur_fn_212( let __v_8: G = __loaded[5]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_212] = [__v_4, __v_5, __v_6, __v_7]; - record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_213] = [__v_4, __v_5, __v_6, __v_7]; + record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -16995,19 +17186,62 @@ fn aiur_fn_212( }) } -const INPUT_SIZE_213: usize = 2; -const IN_213: usize = 2; -const OUT_213: usize = 32; -fn aiur_fn_213( - inp: [G; IN_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], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_213], ExecError> { +) -> Result<[G; OUT_214], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_214] = [__v_9]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_9 + __v_10); + let __ret: [G; OUT_214] = [__v_11]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_215: usize = 2; +const IN_215: usize = 2; +const OUT_215: usize = 32; +fn aiur_fn_215( + inp: [G; IN_215], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_215], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !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_218] = { let __args: [G; IN_218] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_2: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; 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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_3: G = __loaded[0]; @@ -17046,8 +17280,8 @@ fn aiur_fn_213( let __v_36: G = __loaded[33]; match __v_3.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_213] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; - record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_215] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -17057,28 +17291,28 @@ fn aiur_fn_213( }) } -const INPUT_SIZE_214: usize = 2; -const IN_214: usize = 2; -const OUT_214: usize = 1; -fn aiur_fn_214( - inp: [G; IN_214], +const INPUT_SIZE_216: usize = 2; +const IN_216: usize = 2; +const OUT_216: usize = 1; +fn aiur_fn_216( + inp: [G; IN_216], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_214], ExecError> { +) -> Result<[G; OUT_216], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_214] = [__v_0]; - record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_216] = [__v_0]; + record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_216] = unsafe { *(result.output.as_ptr() as *const [G; OUT_216]) }; __ret } else { aiur_fn_216(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -17087,8 +17321,8 @@ fn aiur_fn_214( let __v_8: G = __loaded[3]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_214] = [__v_8]; - record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_216] = [__v_8]; + record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -17100,28 +17334,28 @@ fn aiur_fn_214( }) } -const INPUT_SIZE_215: usize = 2; -const IN_215: usize = 2; -const OUT_215: usize = 1; -fn aiur_fn_215( - inp: [G; IN_215], +const INPUT_SIZE_217: usize = 2; +const IN_217: usize = 2; +const OUT_217: usize = 1; +fn aiur_fn_217( + inp: [G; IN_217], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_215], ExecError> { +) -> Result<[G; OUT_217], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_215] = [__v_0]; - record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_217] = [__v_0]; + record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -17132,8 +17366,8 @@ fn aiur_fn_215( let __v_10: G = __loaded[5]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_215] = [__v_10]; - record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_217] = [__v_10]; + record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -17145,28 +17379,28 @@ fn aiur_fn_215( }) } -const INPUT_SIZE_216: usize = 2; -const IN_216: usize = 2; -const OUT_216: usize = 1; -fn aiur_fn_216( - inp: [G; IN_216], +const INPUT_SIZE_218: usize = 2; +const IN_218: usize = 2; +const OUT_218: usize = 1; +fn aiur_fn_218( + inp: [G; IN_218], record: &mut QueryRecord, io_buffer: &mut IOBuffer, unconstrained: bool, -) -> Result<[G; OUT_216], ExecError> { +) -> Result<[G; OUT_218], ExecError> { stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { let __v_0: G = inp[0]; let __v_1: G = inp[1]; match __v_1.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_216] = [__v_0]; - record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_218] = [__v_0]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { let __v_2: G = G::from_u64(1); let __v_3: G = (__v_1 - __v_2); - let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { if !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_218] = { let __args: [G; IN_218] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; let __v_4: G = __r_arr[0]; let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; 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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; let __v_5: G = __loaded[0]; @@ -17205,8 +17439,8 @@ fn aiur_fn_216( let __v_38: G = __loaded[33]; match __v_5.as_canonical_u64() { 0u64 => { - let __ret: [G; OUT_216] = [__v_38]; - record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + let __ret: [G; OUT_218] = [__v_38]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); return Ok(__ret); }, _ => { @@ -18310,6 +18544,16 @@ pub(crate) fn execute_generated( let __out = aiur_fn_216(__inp, record, io_buffer, false)?; return Ok(__out.to_vec()); }, + 217u64 => { + let __inp: [G; IN_217] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_217(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 218u64 => { + let __inp: [G; IN_218] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_218(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, _ => { return Err(ExecError::InvalidFunIdx(fun_idx)); }, From af6b17962eca4d80a6037659216bc069f9952147 Mon Sep 17 00:00:00 2001 From: Gabriel Barreto Date: Thu, 30 Jul 2026 13:51:00 -0300 Subject: [PATCH 2/4] aiur: raw lookup arguments on branchless functions; group them 2 per step Lookup slots shared across branches superpose their arguments (sum_b sel_b * arg_b - sound because the selectors are mutually exclusive), which costs a degree: every argument becomes degree 2. A branchless function (a single selector, no matches) has exactly one branch per slot, so the weighting is pure waste: its arguments are now sent RAW (degree <= 1) via ConstraintState::gate, with the selector-gated multiplicity alone deciding whether the lookup counts. On padding rows the multiplicity is 0, which makes the (now nonzero, channel-bearing) message value irrelevant - the chained accumulator rides through unchanged, so the witness side needs no change. With degree-1 messages, two lookups fit in one chained-accumulator step at degree 3 (2 message degrees + 1 for the accumulator factor) - within the budget the selector-gated user constraints already pay for - so synthesis sets lookup_group_size = 2 on branchless functions with at least 2 lookups: ceil(L/2) committed stage-2 accumulators instead of L, plus a smaller vk (no selector-mul nodes per argument). Branching functions keep k = 1 (their degree-2 superposed arguments would blow the quotient budget), as do memory and gadget circuits. FunctionLayout.totalWidth mirrors the grouping rule so the circuit statistics stay honest. The recursive-verifier e2e now proves through a branchless entrypoint (store -> load -> call factorial: 4 lookups, k = 2), so the in-circuit grouped logUp fold verifies a real grouped proof and still rejects tampering; the aiur prove/verify and multi-stark suites pass. --- Ix/Aiur/Stages/Bytecode.lean | 12 ++- Tests/MultiStark.lean | 15 ++- crates/aiur/src/constraints.rs | 176 ++++++++++++++++++--------------- crates/aiur/src/synthesis.rs | 29 +++++- 4 files changed, 145 insertions(+), 87 deletions(-) diff --git a/Ix/Aiur/Stages/Bytecode.lean b/Ix/Aiur/Stages/Bytecode.lean index 18c6a5399..cb361af5b 100644 --- a/Ix/Aiur/Stages/Bytecode.lean +++ b/Ix/Aiur/Stages/Bytecode.lean @@ -98,9 +98,15 @@ def FunctionLayout.width (l : FunctionLayout) : Nat := l.inputSize + l.selectors + l.auxiliaries def FunctionLayout.totalWidth (l : FunctionLayout) : Nat := - -- Stage 2 commits max(L, 1) chained partial accumulators (no message - -- inverses); see `multi_stark::lookup::stage2_width`. - l.width + G.extensionDegree * (max l.lookups 1) + -- Stage 2 commits max(⌈L/k⌉, 1) chained partial accumulators (no message + -- inverses); see `multi_stark::lookup::stage2_width`. Mirrors the + -- synthesis grouping rule (`crates/aiur/src/synthesis.rs`): branchless + -- functions (one selector) have raw degree-1 lookup arguments, so their + -- lookups are grouped 2 per accumulator step. + let slots := if l.selectors == 1 && l.lookups >= 2 + then (l.lookups + 1) / 2 + else max l.lookups 1 + l.width + G.extensionDegree * slots structure Function where body : Block diff --git a/Tests/MultiStark.lean b/Tests/MultiStark.lean index 37b081ff0..0ad7bb1da 100644 --- a/Tests/MultiStark.lean +++ b/Tests/MultiStark.lean @@ -96,7 +96,12 @@ def selfTestSuite : IO UInt32 := do -- `recursive-verifier`: prove factorial(5)=120, verify it, reject tampering -- ════════════════════════════════════════════════════════════════════════════ -/-- A tiny Aiur program: `factorial` as the proving entrypoint. -/ +/-- A tiny Aiur program: a BRANCHLESS entrypoint (single selector, no match) +that routes its argument through store/load before calling `factorial`. Its +circuit has 4 lookups (return, store, load, call) with raw degree-1 +arguments, so synthesis groups them 2 per chained-accumulator step +(`lookup_group_size = 2`) — the recursive verifier's grouped logUp fold is +exercised end-to-end alongside the k = 1 branching/memory circuits. -/ def factorialProgram : Source.Toplevel := ⟦ pub fn factorial(n: G) -> G { match n { @@ -104,6 +109,10 @@ def factorialProgram : Source.Toplevel := ⟦ _ => n * factorial(n - 1), } } + + pub fn fact_entry(n: G) -> G { + factorial(load(store(n))) + } ⟧ /-- Inner-proof commitment/FRI parameters. A tractable subset of production @@ -138,9 +147,9 @@ def endToEndSuite : IO UInt32 := do | .error e => IO.eprintln s!"factorial compilation failed: {e}"; return 1 | .ok c => pure c let facSystem := AiurSystem.build facCompiled.bytecode recCommitParams innerFri - let facIdx ← match facCompiled.getFuncIdx `factorial with + let facIdx ← match facCompiled.getFuncIdx `fact_entry with | some i => pure i - | none => IO.eprintln "factorial entrypoint not found"; return 1 + | none => IO.eprintln "fact_entry entrypoint not found"; return 1 -- ── prove factorial(5) = 120 (`G` is a reserved DSL token, spell it qualified) let input := #[Aiur.G.ofNat 5] diff --git a/crates/aiur/src/constraints.rs b/crates/aiur/src/constraints.rs index 018279293..7d6fe6553 100644 --- a/crates/aiur/src/constraints.rs +++ b/crates/aiur/src/constraints.rs @@ -47,6 +47,9 @@ pub struct Constraints { struct ConstraintState { function_index: G, + /// Exactly one selector: the function has a single leaf block (no + /// matches), so every lookup slot is written by exactly one branch. + branchless: bool, layout: FunctionLayout, column: usize, lookup: usize, @@ -69,6 +72,19 @@ impl ConstraintState { sel + self.layout.input_size } + /// Selector-gate a lookup argument. Lookup slots shared across branches + /// superpose their arguments (`Σ_b sel_b·arg_b`, sound because the + /// selectors are mutually exclusive), which needs the weighting — but it + /// costs a degree: the argument becomes degree 2. A branchless function + /// has a single branch, so its arguments are sent RAW (degree ≤ 1): the + /// multiplicity (still selector-gated) alone decides whether the lookup + /// counts, and on inactive (padding) rows a zero multiplicity makes the + /// message value irrelevant. Degree-1 messages leave the degree headroom + /// to group two lookups per chained-accumulator step. + fn gate(&self, sel: &Expr, arg: Expr) -> Expr { + if self.branchless { arg } else { sel.clone() * arg } + } + fn next_lookup(&mut self) -> &mut Lookup { let lookup = &mut self.lookups[self.lookup]; self.lookup += 1; @@ -108,6 +124,7 @@ impl Toplevel { }; let mut state = ConstraintState { function_index: G::from_usize(function_index), + branchless: function.layout.selectors == 1, layout: function.layout, column: 0, lookup: 0, @@ -236,17 +253,17 @@ impl Ctrl { Ctrl::Return(_, values) => { // channel and function index let mut args = vec![ - sel.clone() * konst(function_channel()), - sel.clone() * konst(state.function_index), + state.gate(&sel, konst(function_channel())), + state.gate(&sel, konst(state.function_index)), ]; // input args.extend( (0..state.layout.input_size) - .map(|arg| sel.clone() * state.map[arg].0.clone()), + .map(|arg| state.gate(&sel, state.map[arg].0.clone())), ); // output args.extend( - values.iter().map(|arg| sel.clone() * state.map[*arg].0.clone()), + values.iter().map(|arg| state.gate(&sel, state.map[*arg].0.clone())), ); let lookup = &mut state.lookups[0]; combine_lookup_args(lookup, args); @@ -380,20 +397,23 @@ impl Op { } else { // channel and function index let mut lookup_args = vec![ - sel.clone() * konst(function_channel()), - sel.clone() * konst(G::from_usize(*function_index)), + state.gate(sel, konst(function_channel())), + state.gate(sel, konst(G::from_usize(*function_index))), ]; // input lookup_args.extend( - inputs.iter().map(|arg| sel.clone() * state.map[*arg].0.clone()), + inputs.iter().map(|arg| state.gate(sel, state.map[*arg].0.clone())), ); // output - let output = (0..*output_size).map(|_| { - let col = state.next_auxiliary(); - state.map.push((col.clone(), 1)); - sel.clone() * col - }); - lookup_args.extend(output); + let output: Vec = (0..*output_size) + .map(|_| { + let col = state.next_auxiliary(); + state.map.push((col.clone(), 1)); + col + }) + .collect(); + lookup_args + .extend(output.into_iter().map(|col| state.gate(sel, col))); let lookup = state.next_lookup(); combine_lookup_args(lookup, lookup_args); @@ -406,13 +426,15 @@ impl Op { let ptr = state.next_auxiliary(); state.map.push((ptr.clone(), 1)); let mut lookup_args = vec![ - sel.clone() * konst(memory_channel()), - sel.clone() * konst(G::from_usize(size)), - sel.clone() * ptr, + state.gate(sel, konst(memory_channel())), + state.gate(sel, konst(G::from_usize(size))), + state.gate(sel, ptr), ]; // stored values lookup_args.extend( - values.iter().map(|value| sel.clone() * state.map[*value].0.clone()), + values + .iter() + .map(|value| state.gate(sel, state.map[*value].0.clone())), ); let lookup = state.next_lookup(); @@ -422,17 +444,19 @@ impl Op { Op::Load(size, ptr) => { // channel, size and pointer let mut lookup_args = vec![ - sel.clone() * konst(memory_channel()), - sel.clone() * konst(G::from_usize(*size)), - sel.clone() * state.map[*ptr].0.clone(), + state.gate(sel, konst(memory_channel())), + state.gate(sel, konst(G::from_usize(*size))), + state.gate(sel, state.map[*ptr].0.clone()), ]; // loaded values - let values = (0..*size).map(|_| { - let col = state.next_auxiliary(); - state.map.push((col.clone(), 1)); - sel.clone() * col - }); - lookup_args.extend(values); + let values: Vec = (0..*size) + .map(|_| { + let col = state.next_auxiliary(); + state.map.push((col.clone(), 1)); + col + }) + .collect(); + lookup_args.extend(values.into_iter().map(|col| state.gate(sel, col))); let lookup = state.next_lookup(); combine_lookup_args(lookup, lookup_args); @@ -490,16 +514,14 @@ impl Op { let (x, x_deg) = state.map[*i].clone(); let (y, y_deg) = state.map[*j].clone(); let z = state.next_auxiliary(); + let lookup_args = vec![ + state.gate(sel, konst(u8_add_channel())), + state.gate(sel, x.clone()), + state.gate(sel, y.clone()), + state.gate(sel, z.clone()), + ]; let lookup = state.next_lookup(); - combine_lookup_args( - lookup, - vec![ - sel.clone() * konst(u8_add_channel()), - sel.clone() * x.clone(), - sel.clone() * y.clone(), - sel.clone() * z.clone(), - ], - ); + combine_lookup_args(lookup, lookup_args); lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); let carry = (x + y - z.clone()) * konst(*INV_256); state.map.push((z, 1)); @@ -520,16 +542,14 @@ impl Op { let (x, x_deg) = state.map[*i].clone(); let (y, y_deg) = state.map[*j].clone(); let z = state.next_auxiliary(); + let lookup_args = vec![ + state.gate(sel, konst(u8_sub_channel())), + state.gate(sel, x.clone()), + state.gate(sel, y.clone()), + state.gate(sel, z.clone()), + ]; let lookup = state.next_lookup(); - combine_lookup_args( - lookup, - vec![ - sel.clone() * konst(u8_sub_channel()), - sel.clone() * x.clone(), - sel.clone() * y.clone(), - sel.clone() * z.clone(), - ], - ); + combine_lookup_args(lookup, lookup_args); lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); let borrow = (z.clone() + y - x) * konst(*INV_256); state.map.push((z, 1)); @@ -580,15 +600,13 @@ impl Op { // the inputs), just require `(i, j)` from the byte chip. let x = state.map[*i].0.clone(); let y = state.map[*j].0.clone(); + let lookup_args = vec![ + state.gate(sel, konst(u8_range_check_channel())), + state.gate(sel, x), + state.gate(sel, y), + ]; let lookup = state.next_lookup(); - combine_lookup_args( - lookup, - vec![ - sel.clone() * konst(u8_range_check_channel()), - sel.clone() * x, - sel.clone() * y, - ], - ); + combine_lookup_args(lookup, lookup_args); lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); }, Op::U32LessThan(x_idx, y_idx) => { @@ -651,15 +669,13 @@ impl Op { (&z_bytes[0], &z_bytes[1]), (&z_bytes[2], &z_bytes[3]), ] { + let lookup_args = vec![ + state.gate(sel, konst(rc_channel)), + state.gate(sel, pair.0.clone()), + state.gate(sel, pair.1.clone()), + ]; let lookup = state.next_lookup(); - combine_lookup_args( - lookup, - vec![ - sel.clone() * konst(rc_channel), - sel.clone() * pair.0.clone(), - sel.clone() * pair.1.clone(), - ], - ); + combine_lookup_args(lookup, lookup_args); lookup.multiplicity = lookup.multiplicity.clone() + sel.clone(); } @@ -707,15 +723,19 @@ fn bytes1_constraints( ) { let size = Bytes1.output_size(op); - let mut lookup_args = - vec![sel.clone() * konst(channel), sel.clone() * state.map[byte].0.clone()]; + let mut lookup_args = vec![ + state.gate(&sel, konst(channel)), + state.gate(&sel, state.map[byte].0.clone()), + ]; - let output = (0..size).map(|_| { - let col = state.next_auxiliary(); - state.map.push((col.clone(), 1)); - sel.clone() * col - }); - lookup_args.extend(output); + let output: Vec = (0..size) + .map(|_| { + let col = state.next_auxiliary(); + state.map.push((col.clone(), 1)); + col + }) + .collect(); + lookup_args.extend(output.into_iter().map(|col| state.gate(&sel, col))); let lookup = state.next_lookup(); combine_lookup_args(lookup, lookup_args); @@ -733,17 +753,19 @@ fn bytes2_constraints( let size = Bytes2.output_size(op); let mut lookup_args = vec![ - sel.clone() * konst(channel), - sel.clone() * state.map[i].0.clone(), - sel.clone() * state.map[j].0.clone(), + state.gate(&sel, konst(channel)), + state.gate(&sel, state.map[i].0.clone()), + state.gate(&sel, state.map[j].0.clone()), ]; - let output = (0..size).map(|_| { - let col = state.next_auxiliary(); - state.map.push((col.clone(), 1)); - sel.clone() * col - }); - lookup_args.extend(output); + let output: Vec = (0..size) + .map(|_| { + let col = state.next_auxiliary(); + state.map.push((col.clone(), 1)); + col + }) + .collect(); + lookup_args.extend(output.into_iter().map(|col| state.gate(&sel, col))); let lookup = state.next_lookup(); combine_lookup_args(lookup, lookup_args); diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 3d0ca55e8..bd6022898 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -63,7 +63,8 @@ impl AiurSystem { |main_width: usize, preprocessed: Option>, constraints: Vec>, - lookups: Vec>>| { + lookups: Vec>>, + lookup_group_size: usize| { slot_widths.push(lookups.iter().map(|l| l.args.len()).collect()); circuit_inputs.push(CircuitInputs { main_width, @@ -71,7 +72,7 @@ impl AiurSystem { constraints, ext_constraints: vec![], lookups, - lookup_group_size: 1, + lookup_group_size, }); }; @@ -81,12 +82,30 @@ impl AiurSystem { continue; } let (constraints, lookups) = toplevel.build_constraints(i); - push_circuit(constraints.width, None, constraints.zeros, lookups); + // A branchless function's lookup arguments are sent raw (degree 1; + // see `ConstraintState::gate`), so two lookups fit in one chained + // accumulator step at degree 3 — within the degree the selector-gated + // constraints already pay for. Branching functions keep k = 1: their + // superposed arguments are degree 2, and grouping would push the + // logUp constraints past the quotient budget. + let group_size = + if toplevel.functions[i].layout.selectors == 1 && lookups.len() >= 2 { + 2 + } else { + 1 + }; + push_circuit( + constraints.width, + None, + constraints.zeros, + lookups, + group_size, + ); } // Memories. for &size in &toplevel.memory_sizes { let (memory, constraints, lookups) = Memory::build(size); - push_circuit(memory.width, None, constraints, lookups); + push_circuit(memory.width, None, constraints, lookups, 1); } // Gadgets. push_circuit( @@ -94,12 +113,14 @@ impl AiurSystem { Bytes1.preprocessed(), vec![], Bytes1.lookups(), + 1, ); push_circuit( Bytes2.main_width(), Bytes2.preprocessed(), vec![], Bytes2.lookups(), + 1, ); let config = AiurConfig::new(commitment_parameters, fri_parameters); From 9123238a0909ddfae5d320a545b0f330761061dc Mon Sep 17 00:00:00 2001 From: Gabriel Barreto Date: Thu, 30 Jul 2026 14:02:56 -0300 Subject: [PATCH 3/4] tests: re-pin kernel FFT-cost checks for branchless lookup grouping The branchless raw-argument + k = 2 grouping change narrows every branchless function circuit's stage-2 width (ceil(L/2) accumulators instead of L), which the statistics reflect via FunctionLayout.totalWidth. Re-pin all 66 kernel-check FFT-cost constants to the measured values - a 15-19% reduction across the board (e.g. Nat.add_comm 48,989,755 -> 40,570,358; Vector.append 2,210,433,232 -> 1,877,570,289). ixvm suite fully green, incl. codegen/bytecode parity; aiur-hashes (blake3 + sha256 prove/verify, grouping-heavy branchless circuits) and rbtree-map suites pass. --- Tests/Ix/IxVM.lean | 132 ++++++++++++++++++++++----------------------- 1 file changed, 66 insertions(+), 66 deletions(-) diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index 8edc12e93..ef3146224 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -174,92 +174,92 @@ public def kernelCheck (name : Lean.Name) (env : Lean.Environment) : observed cost in the message so it can be pasted back. -/ private def kernelCheckEntries : List (String × Nat) := [ -- Stdlib - ("HEq", 1_422_377), - ("HEq.rec", 2_248_839), - ("Eq.rec", 2_167_118), - ("Nat", 1_561_822), - ("Nat.add", 11_316_552), - ("Nat.add_comm", 47_091_221), - ("Nat.decEq", 58_299_184), - ("Nat.decLe", 163_010_330), - ("Nat.sub_le_of_le_add", 434_240_570), + ("HEq", 1_311_066), + ("HEq.rec", 2_032_043), + ("Eq.rec", 1_950_745), + ("Nat", 1_418_963), + ("Nat.add", 9_754_134), + ("Nat.add_comm", 40_570_358), + ("Nat.decEq", 50_907_662), + ("Nat.decLe", 141_717_612), + ("Nat.sub_le_of_le_add", 377_906_042), -- Offset-stuck regression driver: the succ-step unfold of `x >>> n` -- into a symbolic-base `Nat.div` chain. Exercises the div/mod -- offset-stuck path where rebuilding the stuck form with the wrong -- (add) head corrupted offset-aware def-eq and sent `x >>> k` -- comparisons into full delta-unfolds of the division algorithm. - ("Nat.shiftRight_succ", 317_421_449), + ("Nat.shiftRight_succ", 275_870_550), -- Newly-unlocked targets (level_leq Géran normalize). - ("Trans.mk", 2_364_054), - ("Array.append_assoc", 2_056_848_911), - ("Vector.append", 2_117_995_739), + ("Trans.mk", 2_182_270), + ("Array.append_assoc", 1_824_436_202), + ("Vector.append", 1_877_570_289), -- Primitive reduction theorems (`IxVMPrim`) - ("IxVMPrim.nat_add_lit", 24_569_820), - ("IxVMPrim.nat_sub_lit", 29_716_542), - ("IxVMPrim.nat_mul_lit", 21_633_770), - ("IxVMPrim.nat_mul_big", 21_121_333), - ("IxVMPrim.nat_div_lit", 309_509_856), - ("IxVMPrim.nat_mod_lit", 316_710_104), - ("IxVMPrim.nat_succ_lit", 6_388_951), - ("IxVMPrim.nat_pred_lit", 12_937_436), - ("IxVMPrim.nat_gcd_lit", 512_049_961), - ("IxVMPrim.nat_land_lit", 863_876_396), - ("IxVMPrim.nat_lor_lit", 864_538_928), - ("IxVMPrim.nat_xor_lit", 871_819_843), - ("IxVMPrim.nat_shl_lit", 30_606_446), - ("IxVMPrim.nat_shr_lit", 313_936_489), - ("IxVMPrim.nat_pow_big", 63_371_031), - ("IxVMPrim.nat_beq_lit", 21_216_717), - ("IxVMPrim.nat_ble_lit", 19_681_496), - ("IxVMPrim.nat_cases_big", 12_574_731), - ("IxVMPrim.nat_dec_le", 168_723_623), - ("IxVMPrim.nat_dec_lt", 172_272_111), - ("IxVMPrim.nat_dec_eq", 70_281_013), - ("IxVMPrim.str_size_lit", 615_742_529), - ("IxVMPrim.bv_to_nat_lit", 489_428_838), + ("IxVMPrim.nat_add_lit", 21_066_061), + ("IxVMPrim.nat_sub_lit", 25_370_916), + ("IxVMPrim.nat_mul_lit", 18_428_229), + ("IxVMPrim.nat_mul_big", 18_008_332), + ("IxVMPrim.nat_div_lit", 268_816_446), + ("IxVMPrim.nat_mod_lit", 274_976_552), + ("IxVMPrim.nat_succ_lit", 5_455_078), + ("IxVMPrim.nat_pred_lit", 10_974_720), + ("IxVMPrim.nat_gcd_lit", 444_833_855), + ("IxVMPrim.nat_land_lit", 748_827_086), + ("IxVMPrim.nat_lor_lit", 749_361_728), + ("IxVMPrim.nat_xor_lit", 755_593_746), + ("IxVMPrim.nat_shl_lit", 26_062_877), + ("IxVMPrim.nat_shr_lit", 272_520_921), + ("IxVMPrim.nat_pow_big", 56_599_836), + ("IxVMPrim.nat_beq_lit", 18_152_230), + ("IxVMPrim.nat_ble_lit", 16_860_990), + ("IxVMPrim.nat_cases_big", 10_702_720), + ("IxVMPrim.nat_dec_le", 146_626_818), + ("IxVMPrim.nat_dec_lt", 149_654_295), + ("IxVMPrim.nat_dec_eq", 61_183_664), + ("IxVMPrim.str_size_lit", 533_383_840), + ("IxVMPrim.bv_to_nat_lit", 424_944_495), -- Mutual block + multi-member recursors - ("IxVMInd.Even", 22_796_180), - ("IxVMInd.Odd", 22_559_147), - ("IxVMInd.Even.rec", 27_740_095), - ("IxVMInd.Odd.rec", 27_737_306), + ("IxVMInd.Even", 19_537_275), + ("IxVMInd.Odd", 19_345_999), + ("IxVMInd.Even.rec", 23_745_428), + ("IxVMInd.Odd.rec", 23_742_640), -- Nested inductive + aux recursor (Tree.mk : List Tree → Tree) - ("IxVMInd.Tree", 2_253_665), - ("IxVMInd.Tree.rec", 4_184_733), + ("IxVMInd.Tree", 2_003_773), + ("IxVMInd.Tree.rec", 3_662_686), -- Aux dedup: distinct spec_params on one external inductive (3 motives). - ("IxVMInd.DedupM", 4_231_601), - ("IxVMInd.DedupM.rec", 6_964_804), + ("IxVMInd.DedupM", 3_634_342), + ("IxVMInd.DedupM.rec", 5_987_107), -- Aux dedup de-lift guard: equal spec_params at field depths 0 and 2. - ("IxVMInd.DepthM", 3_135_027), - ("IxVMInd.DepthM.rec", 5_460_512), + ("IxVMInd.DepthM", 2_734_439), + ("IxVMInd.DepthM.rec", 4_734_460), -- Edge cases from prelude - ("String.Internal.append", 608_754_163), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 914_698_909), + ("String.Internal.append", 527_678_519), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 792_940_959), -- Aux recursor with transitively-nested inductives (Syntax → Array Syntax -- → List Syntax); shard 53 regression driver. - ("Lean.Syntax.rec", 631_819_629), + ("Lean.Syntax.rec", 547_811_632), -- Canonical aux order with structurally-distinct exts that tie weak -- through sentinels: the trailing identity marker must decide by -- external address, matching compile order (the Lean.Json.rec bug; -- Json itself is ~68G FFT, far too heavy to pin here). AuxTie is -- verified to fail on the pre-marker kernel. - ("IxVMInd.AuxTie", 68_499_165), - ("IxVMInd.AuxTie.rec", 77_049_263), + ("IxVMInd.AuxTie", 58_310_812), + ("IxVMInd.AuxTie.rec", 65_765_486), -- Parameterized Prop class whose ctor field references the params -- under local ∀-binders: is_rec_field's classification whnf must not -- build a context from the peeled binder doms (frame-level param refs -- give those doms loose ranges exceeding the local depth, running the -- ctx-trim cut walk off the end of the list). - ("String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec", 850_286_686), + ("String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec", 740_860_780), -- Universe-polymorphic nested inductive: aux occurrence universes must -- carry the univ_offset-shifted frame into minor construction. - ("Lean.Widget.TaggedText.rec", 613_779_550), + ("Lean.Widget.TaggedText.rec", 532_182_539), -- Aux-member recursors: the canonical param walk peels the PRIMARY -- inductive's type, not self's. - ("Lean.Doc.Part.rec", 639_391_067), + ("Lean.Doc.Part.rec", 554_642_380), -- Multi-aux mutual block whose canonical aux order hinges on comparing -- stored (Succ-distributed-into-Max) levels structurally: level_max -- must not factor Succ back out of Max. - ("Lean.Doc.Block.rec", 670_857_859), + ("Lean.Doc.Block.rec", 582_356_063), -- Evaporated-aux canonicalization (Tests/Ix/Compile/Mutual.lean AuxDedup*): -- SCC splitting strands `rec_N` auxes whose spec-param inductives moved to -- other SCCs; their claims alias the external inductive's recursor @@ -267,23 +267,23 @@ private def kernelCheckEntries : List (String × Nat) := [ -- whose claims are literally the same `List.rec` closure. AuxDedupMixed -- mixes one genuine canonical aux (`M.rec_1`, over `List M`) with one -- evaporated alias (`M.rec_2`, over `List B`). - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 3_084_348), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 3_873_841), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 2_627_832), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 2_627_832), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 2_627_832), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 3_115_727), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 5_379_916), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 5_381_872), - ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 2_627_832), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 2_683_174), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 3_353_451), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 2_339_722), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 2_339_722), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 2_339_722), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 2_714_493), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 4_653_576), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 4_655_533), + ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 2_339_722), -- Structural string fold (StringReduction strOfListFoldSize*): -- `utf8ByteSize` over a `String.ofList [chars]` application. The unary -- native rule misses (argument is not a literal), so the check -- normalizes the constructor build through the byte model — per -- character through `Char.ofNat` validity and `List.utf8Encode`. Pins -- the in-circuit cost of that fold. - ("strOfListFoldSize", 736_138_090), - ("strOfListFoldSizeAscii", 720_671_439), + ("strOfListFoldSize", 641_872_830), + ("strOfListFoldSizeAscii", 626_401_183), ] private def nameOfString (str : String) : Lean.Name := From 11cb3c99064cab0f3f843d60ee60d52a8e7f8fd5 Mon Sep 17 00:00:00 2001 From: Gabriel Barreto Date: Fri, 31 Jul 2026 13:50:43 -0300 Subject: [PATCH 4/4] aiur: group the byte chips' lookups 2 per chained step The Bytes1/Bytes2 lookup arguments are preprocessed columns and their multiplicities main columns - all degree 1, same shape as branchless function lookups - so they group 2 per chained-accumulator step at degree 3. Stage-2 accumulators: Bytes1 3 -> 2, Bytes2 10 -> 5 at its fixed height of 65536 rows, where the width saving actually pays. The kernel FFT-cost pins are untouched: the statistics cover function and memory circuits only. aiur, aiur-hashes (blake3/sha256 drive the byte chips hard), ixvm, multi-stark, and recursive-verifier suites all pass. --- crates/aiur/src/synthesis.rs | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index bd6022898..9914e700a 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -107,20 +107,23 @@ impl AiurSystem { let (memory, constraints, lookups) = Memory::build(size); push_circuit(memory.width, None, constraints, lookups, 1); } - // Gadgets. + // Gadgets. The byte chips' lookup arguments are preprocessed columns + // and their multiplicities main columns (all degree 1), so their + // lookups also group 2 per chained step at degree 3 — halving the + // stage-2 accumulators (Bytes2: 10 → 5 at height 65536). push_circuit( Bytes1.main_width(), Bytes1.preprocessed(), vec![], Bytes1.lookups(), - 1, + 2, ); push_circuit( Bytes2.main_width(), Bytes2.preprocessed(), vec![], Bytes2.lookups(), - 1, + 2, ); let config = AiurConfig::new(commitment_parameters, fri_parameters);